_ Git - ldk-c-bindings/blob - lightning-c-bindings/include/lightning.h

   1 /* Text to put at the beginning of the generated file. Probably a license. */
   2
   3 /* Generated with cbindgen:0.16.0 */
   4
   5 /* Warning, this file is autogenerated by cbindgen. Don't modify this manually. */
   6
   7 #include <stdarg.h>
   8 #include <stdbool.h>
   9 #include <stdint.h>
  10
  11
  12 /**
  13  * An error when accessing the chain via [`Access`].
  14  */
  15 typedef enum LDKAccessError {
  16    /**
  17     * The requested chain is unknown.
  18     */
  19    LDKAccessError_UnknownChain,
  20    /**
  21     * The requested transaction doesn't exist or hasn't confirmed.
  22     */
  23    LDKAccessError_UnknownTx,
  24    /**
  25     * Must be last for serialization purposes
  26     */
  27    LDKAccessError_Sentinel,
  28 } LDKAccessError;
  29
  30 /**
  31  * An error enum representing a failure to persist a channel monitor update.
  32  */
  33 typedef enum LDKChannelMonitorUpdateErr {
  34    /**
  35     * Used to indicate a temporary failure (eg connection to a watchtower or remote backup of
  36     * our state failed, but is expected to succeed at some point in the future).
  37     *
  38     * Such a failure will \"freeze\" a channel, preventing us from revoking old states or
  39     * submitting new commitment transactions to the counterparty. Once the update(s) which failed
  40     * have been successfully applied, ChannelManager::channel_monitor_updated can be used to
  41     * restore the channel to an operational state.
  42     *
  43     * Note that a given ChannelManager will *never* re-generate a given ChannelMonitorUpdate. If
  44     * you return a TemporaryFailure you must ensure that it is written to disk safely before
  45     * writing out the latest ChannelManager state.
  46     *
  47     * Even when a channel has been \"frozen\" updates to the ChannelMonitor can continue to occur
  48     * (eg if an inbound HTLC which we forwarded was claimed upstream resulting in us attempting
  49     * to claim it on this channel) and those updates must be applied wherever they can be. At
  50     * least one such updated ChannelMonitor must be persisted otherwise PermanentFailure should
  51     * be returned to get things on-chain ASAP using only the in-memory copy. Obviously updates to
  52     * the channel which would invalidate previous ChannelMonitors are not made when a channel has
  53     * been \"frozen\".
  54     *
  55     * Note that even if updates made after TemporaryFailure succeed you must still call
  56     * channel_monitor_updated to ensure you have the latest monitor and re-enable normal channel
  57     * operation.
  58     *
  59     * Note that the update being processed here will not be replayed for you when you call
  60     * ChannelManager::channel_monitor_updated, so you must store the update itself along
  61     * with the persisted ChannelMonitor on your own local disk prior to returning a
  62     * TemporaryFailure. You may, of course, employ a journaling approach, storing only the
  63     * ChannelMonitorUpdate on disk without updating the monitor itself, replaying the journal at
  64     * reload-time.
  65     *
  66     * For deployments where a copy of ChannelMonitors and other local state are backed up in a
  67     * remote location (with local copies persisted immediately), it is anticipated that all
  68     * updates will return TemporaryFailure until the remote copies could be updated.
  69     */
  70    LDKChannelMonitorUpdateErr_TemporaryFailure,
  71    /**
  72     * Used to indicate no further channel monitor updates will be allowed (eg we've moved on to a
  73     * different watchtower and cannot update with all watchtowers that were previously informed
  74     * of this channel).
  75     *
  76     * At reception of this error, ChannelManager will force-close the channel and return at
  77     * least a final ChannelMonitorUpdate::ChannelForceClosed which must be delivered to at
  78     * least one ChannelMonitor copy. Revocation secret MUST NOT be released and offchain channel
  79     * update must be rejected.
  80     *
  81     * This failure may also signal a failure to update the local persisted copy of one of
  82     * the channel monitor instance.
  83     *
  84     * Note that even when you fail a holder commitment transaction update, you must store the
  85     * update to ensure you can claim from it in case of a duplicate copy of this ChannelMonitor
  86     * broadcasts it (e.g distributed channel-monitor deployment)
  87     *
  88     * In case of distributed watchtowers deployment, the new version must be written to disk, as
  89     * state may have been stored but rejected due to a block forcing a commitment broadcast. This
  90     * storage is used to claim outputs of rejected state confirmed onchain by another watchtower,
  91     * lagging behind on block processing.
  92     */
  93    LDKChannelMonitorUpdateErr_PermanentFailure,
  94    /**
  95     * Must be last for serialization purposes
  96     */
  97    LDKChannelMonitorUpdateErr_Sentinel,
  98 } LDKChannelMonitorUpdateErr;
  99
 100 /**
 101  * An enum that represents the speed at which we want a transaction to confirm used for feerate
 102  * estimation.
 103  */
 104 typedef enum LDKConfirmationTarget {
 105    /**
 106     * We are happy with this transaction confirming slowly when feerate drops some.
 107     */
 108    LDKConfirmationTarget_Background,
 109    /**
 110     * We'd like this transaction to confirm without major delay, but 12-18 blocks is fine.
 111     */
 112    LDKConfirmationTarget_Normal,
 113    /**
 114     * We'd like this transaction to confirm in the next few blocks.
 115     */
 116    LDKConfirmationTarget_HighPriority,
 117    /**
 118     * Must be last for serialization purposes
 119     */
 120    LDKConfirmationTarget_Sentinel,
 121 } LDKConfirmationTarget;
 122
 123 /**
 124  * An enum representing the available verbosity levels of the logger.
 125  */
 126 typedef enum LDKLevel {
 127    /**
 128     *Designates logger being silent
 129     */
 130    LDKLevel_Off,
 131    /**
 132     * Designates very serious errors
 133     */
 134    LDKLevel_Error,
 135    /**
 136     * Designates hazardous situations
 137     */
 138    LDKLevel_Warn,
 139    /**
 140     * Designates useful information
 141     */
 142    LDKLevel_Info,
 143    /**
 144     * Designates lower priority information
 145     */
 146    LDKLevel_Debug,
 147    /**
 148     * Designates very low priority, often extremely verbose, information
 149     */
 150    LDKLevel_Trace,
 151    /**
 152     * Must be last for serialization purposes
 153     */
 154    LDKLevel_Sentinel,
 155 } LDKLevel;
 156
 157 typedef enum LDKNetwork {
 158    LDKNetwork_Bitcoin,
 159    LDKNetwork_Testnet,
 160    LDKNetwork_Regtest,
 161    LDKNetwork_Signet,
 162    /**
 163     * Must be last for serialization purposes
 164     */
 165    LDKNetwork_Sentinel,
 166 } LDKNetwork;
 167
 168 typedef enum LDKSecp256k1Error {
 169    LDKSecp256k1Error_IncorrectSignature,
 170    LDKSecp256k1Error_InvalidMessage,
 171    LDKSecp256k1Error_InvalidPublicKey,
 172    LDKSecp256k1Error_InvalidSignature,
 173    LDKSecp256k1Error_InvalidSecretKey,
 174    LDKSecp256k1Error_InvalidRecoveryId,
 175    LDKSecp256k1Error_InvalidTweak,
 176    LDKSecp256k1Error_TweakCheckFailed,
 177    LDKSecp256k1Error_NotEnoughMemory,
 178    /**
 179     * Must be last for serialization purposes
 180     */
 181    LDKSecp256k1Error_Sentinel,
 182 } LDKSecp256k1Error;
 183
 184 /**
 185  * A serialized transaction, in (pointer, length) form.
 186  *
 187  * This type optionally owns its own memory, and thus the semantics around access change based on
 188  * the `data_is_owned` flag. If `data_is_owned` is set, you must call `Transaction_free` to free
 189  * the underlying buffer before the object goes out of scope. If `data_is_owned` is not set, any
 190  * access to the buffer after the scope in which the object was provided to you is invalid. eg,
 191  * access after you return from the call in which a `!data_is_owned` `Transaction` is provided to
 192  * you would be invalid.
 193  *
 194  * Note that, while it may change in the future, because transactions on the Rust side are stored
 195  * in a deserialized form, all `Transaction`s generated on the Rust side will have `data_is_owned`
 196  * set. Similarly, while it may change in the future, all `Transaction`s you pass to Rust may have
 197  * `data_is_owned` either set or unset at your discretion.
 198  */
 199 typedef struct LDKTransaction {
 200    /**
 201     * This is non-const for your convenience, an object passed to Rust is never written to.
 202     */
 203    uint8_t *data;
 204    uintptr_t datalen;
 205    bool data_is_owned;
 206 } LDKTransaction;
 207
 208 typedef struct LDKCVec_u8Z {
 209    uint8_t *data;
 210    uintptr_t datalen;
 211 } LDKCVec_u8Z;
 212
 213 /**
 214  * A transaction output including a scriptPubKey and value.
 215  * This type *does* own its own memory, so must be free'd appropriately.
 216  */
 217 typedef struct LDKTxOut {
 218    struct LDKCVec_u8Z script_pubkey;
 219    uint64_t value;
 220 } LDKTxOut;
 221
 222 typedef struct LDKSecretKey {
 223    uint8_t bytes[32];
 224 } LDKSecretKey;
 225
 226 typedef union LDKCResult_SecretKeyErrorZPtr {
 227    struct LDKSecretKey *result;
 228    enum LDKSecp256k1Error *err;
 229 } LDKCResult_SecretKeyErrorZPtr;
 230
 231 typedef struct LDKCResult_SecretKeyErrorZ {
 232    union LDKCResult_SecretKeyErrorZPtr contents;
 233    bool result_ok;
 234 } LDKCResult_SecretKeyErrorZ;
 235
 236 typedef struct LDKPublicKey {
 237    uint8_t compressed_form[33];
 238 } LDKPublicKey;
 239
 240 typedef union LDKCResult_PublicKeyErrorZPtr {
 241    struct LDKPublicKey *result;
 242    enum LDKSecp256k1Error *err;
 243 } LDKCResult_PublicKeyErrorZPtr;
 244
 245 typedef struct LDKCResult_PublicKeyErrorZ {
 246    union LDKCResult_PublicKeyErrorZPtr contents;
 247    bool result_ok;
 248 } LDKCResult_PublicKeyErrorZ;
 249
 250
 251
 252 /**
 253  * The set of public keys which are used in the creation of one commitment transaction.
 254  * These are derived from the channel base keys and per-commitment data.
 255  *
 256  * A broadcaster key is provided from potential broadcaster of the computed transaction.
 257  * A countersignatory key is coming from a protocol participant unable to broadcast the
 258  * transaction.
 259  *
 260  * These keys are assumed to be good, either because the code derived them from
 261  * channel basepoints via the new function, or they were obtained via
 262  * CommitmentTransaction.trust().keys() because we trusted the source of the
 263  * pre-calculated keys.
 264  */
 265 typedef struct MUST_USE_STRUCT LDKTxCreationKeys {
 266    /**
 267     * A pointer to the opaque Rust object.
 268     * Nearly everywhere, inner must be non-null, however in places where
 269     * the Rust equivalent takes an Option, it may be set to null to indicate None.
 270     */
 271    LDKnativeTxCreationKeys *inner;
 272    /**
 273     * Indicates that this is the only struct which contains the same pointer.
 274     * Rust functions which take ownership of an object provided via an argument require
 275     * this to be true and invalidate the object pointed to by inner.
 276     */
 277    bool is_owned;
 278 } LDKTxCreationKeys;
 279
 280
 281
 282 /**
 283  * An error in decoding a message or struct.
 284  */
 285 typedef struct MUST_USE_STRUCT LDKDecodeError {
 286    /**
 287     * A pointer to the opaque Rust object.
 288     * Nearly everywhere, inner must be non-null, however in places where
 289     * the Rust equivalent takes an Option, it may be set to null to indicate None.
 290     */
 291    LDKnativeDecodeError *inner;
 292    /**
 293     * Indicates that this is the only struct which contains the same pointer.
 294     * Rust functions which take ownership of an object provided via an argument require
 295     * this to be true and invalidate the object pointed to by inner.
 296     */
 297    bool is_owned;
 298 } LDKDecodeError;
 299
 300 typedef union LDKCResult_TxCreationKeysDecodeErrorZPtr {
 301    struct LDKTxCreationKeys *result;
 302    struct LDKDecodeError *err;
 303 } LDKCResult_TxCreationKeysDecodeErrorZPtr;
 304
 305 typedef struct LDKCResult_TxCreationKeysDecodeErrorZ {
 306    union LDKCResult_TxCreationKeysDecodeErrorZPtr contents;
 307    bool result_ok;
 308 } LDKCResult_TxCreationKeysDecodeErrorZ;
 309
 310
 311
 312 /**
 313  * One counterparty's public keys which do not change over the life of a channel.
 314  */
 315 typedef struct MUST_USE_STRUCT LDKChannelPublicKeys {
 316    /**
 317     * A pointer to the opaque Rust object.
 318     * Nearly everywhere, inner must be non-null, however in places where
 319     * the Rust equivalent takes an Option, it may be set to null to indicate None.
 320     */
 321    LDKnativeChannelPublicKeys *inner;
 322    /**
 323     * Indicates that this is the only struct which contains the same pointer.
 324     * Rust functions which take ownership of an object provided via an argument require
 325     * this to be true and invalidate the object pointed to by inner.
 326     */
 327    bool is_owned;
 328 } LDKChannelPublicKeys;
 329
 330 typedef union LDKCResult_ChannelPublicKeysDecodeErrorZPtr {
 331    struct LDKChannelPublicKeys *result;
 332    struct LDKDecodeError *err;
 333 } LDKCResult_ChannelPublicKeysDecodeErrorZPtr;
 334
 335 typedef struct LDKCResult_ChannelPublicKeysDecodeErrorZ {
 336    union LDKCResult_ChannelPublicKeysDecodeErrorZPtr contents;
 337    bool result_ok;
 338 } LDKCResult_ChannelPublicKeysDecodeErrorZ;
 339
 340 typedef union LDKCResult_TxCreationKeysErrorZPtr {
 341    struct LDKTxCreationKeys *result;
 342    enum LDKSecp256k1Error *err;
 343 } LDKCResult_TxCreationKeysErrorZPtr;
 344
 345 typedef struct LDKCResult_TxCreationKeysErrorZ {
 346    union LDKCResult_TxCreationKeysErrorZPtr contents;
 347    bool result_ok;
 348 } LDKCResult_TxCreationKeysErrorZ;
 349
 350
 351
 352 /**
 353  * Information about an HTLC as it appears in a commitment transaction
 354  */
 355 typedef struct MUST_USE_STRUCT LDKHTLCOutputInCommitment {
 356    /**
 357     * A pointer to the opaque Rust object.
 358     * Nearly everywhere, inner must be non-null, however in places where
 359     * the Rust equivalent takes an Option, it may be set to null to indicate None.
 360     */
 361    LDKnativeHTLCOutputInCommitment *inner;
 362    /**
 363     * Indicates that this is the only struct which contains the same pointer.
 364     * Rust functions which take ownership of an object provided via an argument require
 365     * this to be true and invalidate the object pointed to by inner.
 366     */
 367    bool is_owned;
 368 } LDKHTLCOutputInCommitment;
 369
 370 typedef union LDKCResult_HTLCOutputInCommitmentDecodeErrorZPtr {
 371    struct LDKHTLCOutputInCommitment *result;
 372    struct LDKDecodeError *err;
 373 } LDKCResult_HTLCOutputInCommitmentDecodeErrorZPtr;
 374
 375 typedef struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ {
 376    union LDKCResult_HTLCOutputInCommitmentDecodeErrorZPtr contents;
 377    bool result_ok;
 378 } LDKCResult_HTLCOutputInCommitmentDecodeErrorZ;
 379
 380
 381
 382 /**
 383  * Late-bound per-channel counterparty data used to build transactions.
 384  */
 385 typedef struct MUST_USE_STRUCT LDKCounterpartyChannelTransactionParameters {
 386    /**
 387     * A pointer to the opaque Rust object.
 388     * Nearly everywhere, inner must be non-null, however in places where
 389     * the Rust equivalent takes an Option, it may be set to null to indicate None.
 390     */
 391    LDKnativeCounterpartyChannelTransactionParameters *inner;
 392    /**
 393     * Indicates that this is the only struct which contains the same pointer.
 394     * Rust functions which take ownership of an object provided via an argument require
 395     * this to be true and invalidate the object pointed to by inner.
 396     */
 397    bool is_owned;
 398 } LDKCounterpartyChannelTransactionParameters;
 399
 400 typedef union LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZPtr {
 401    struct LDKCounterpartyChannelTransactionParameters *result;
 402    struct LDKDecodeError *err;
 403 } LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZPtr;
 404
 405 typedef struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ {
 406    union LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZPtr contents;
 407    bool result_ok;
 408 } LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ;
 409
 410
 411
 412 /**
 413  * Per-channel data used to build transactions in conjunction with the per-commitment data (CommitmentTransaction).
 414  * The fields are organized by holder/counterparty.
 415  *
 416  * Normally, this is converted to the broadcaster/countersignatory-organized DirectedChannelTransactionParameters
 417  * before use, via the as_holder_broadcastable and as_counterparty_broadcastable functions.
 418  */
 419 typedef struct MUST_USE_STRUCT LDKChannelTransactionParameters {
 420    /**
 421     * A pointer to the opaque Rust object.
 422     * Nearly everywhere, inner must be non-null, however in places where
 423     * the Rust equivalent takes an Option, it may be set to null to indicate None.
 424     */
 425    LDKnativeChannelTransactionParameters *inner;
 426    /**
 427     * Indicates that this is the only struct which contains the same pointer.
 428     * Rust functions which take ownership of an object provided via an argument require
 429     * this to be true and invalidate the object pointed to by inner.
 430     */
 431    bool is_owned;
 432 } LDKChannelTransactionParameters;
 433
 434 typedef union LDKCResult_ChannelTransactionParametersDecodeErrorZPtr {
 435    struct LDKChannelTransactionParameters *result;
 436    struct LDKDecodeError *err;
 437 } LDKCResult_ChannelTransactionParametersDecodeErrorZPtr;
 438
 439 typedef struct LDKCResult_ChannelTransactionParametersDecodeErrorZ {
 440    union LDKCResult_ChannelTransactionParametersDecodeErrorZPtr contents;
 441    bool result_ok;
 442 } LDKCResult_ChannelTransactionParametersDecodeErrorZ;
 443
 444 typedef struct LDKSignature {
 445    uint8_t compact_form[64];
 446 } LDKSignature;
 447
 448 typedef struct LDKCVec_SignatureZ {
 449    struct LDKSignature *data;
 450    uintptr_t datalen;
 451 } LDKCVec_SignatureZ;
 452
 453
 454
 455 /**
 456  * Information needed to build and sign a holder's commitment transaction.
 457  *
 458  * The transaction is only signed once we are ready to broadcast.
 459  */
 460 typedef struct MUST_USE_STRUCT LDKHolderCommitmentTransaction {
 461    /**
 462     * A pointer to the opaque Rust object.
 463     * Nearly everywhere, inner must be non-null, however in places where
 464     * the Rust equivalent takes an Option, it may be set to null to indicate None.
 465     */
 466    LDKnativeHolderCommitmentTransaction *inner;
 467    /**
 468     * Indicates that this is the only struct which contains the same pointer.
 469     * Rust functions which take ownership of an object provided via an argument require
 470     * this to be true and invalidate the object pointed to by inner.
 471     */
 472    bool is_owned;
 473 } LDKHolderCommitmentTransaction;
 474
 475 typedef union LDKCResult_HolderCommitmentTransactionDecodeErrorZPtr {
 476    struct LDKHolderCommitmentTransaction *result;
 477    struct LDKDecodeError *err;
 478 } LDKCResult_HolderCommitmentTransactionDecodeErrorZPtr;
 479
 480 typedef struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ {
 481    union LDKCResult_HolderCommitmentTransactionDecodeErrorZPtr contents;
 482    bool result_ok;
 483 } LDKCResult_HolderCommitmentTransactionDecodeErrorZ;
 484
 485
 486
 487 /**
 488  * A pre-built Bitcoin commitment transaction and its txid.
 489  */
 490 typedef struct MUST_USE_STRUCT LDKBuiltCommitmentTransaction {
 491    /**
 492     * A pointer to the opaque Rust object.
 493     * Nearly everywhere, inner must be non-null, however in places where
 494     * the Rust equivalent takes an Option, it may be set to null to indicate None.
 495     */
 496    LDKnativeBuiltCommitmentTransaction *inner;
 497    /**
 498     * Indicates that this is the only struct which contains the same pointer.
 499     * Rust functions which take ownership of an object provided via an argument require
 500     * this to be true and invalidate the object pointed to by inner.
 501     */
 502    bool is_owned;
 503 } LDKBuiltCommitmentTransaction;
 504
 505 typedef union LDKCResult_BuiltCommitmentTransactionDecodeErrorZPtr {
 506    struct LDKBuiltCommitmentTransaction *result;
 507    struct LDKDecodeError *err;
 508 } LDKCResult_BuiltCommitmentTransactionDecodeErrorZPtr;
 509
 510 typedef struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ {
 511    union LDKCResult_BuiltCommitmentTransactionDecodeErrorZPtr contents;
 512    bool result_ok;
 513 } LDKCResult_BuiltCommitmentTransactionDecodeErrorZ;
 514
 515
 516
 517 /**
 518  * This class tracks the per-transaction information needed to build a commitment transaction and to
 519  * actually build it and sign.  It is used for holder transactions that we sign only when needed
 520  * and for transactions we sign for the counterparty.
 521  *
 522  * This class can be used inside a signer implementation to generate a signature given the relevant
 523  * secret key.
 524  */
 525 typedef struct MUST_USE_STRUCT LDKCommitmentTransaction {
 526    /**
 527     * A pointer to the opaque Rust object.
 528     * Nearly everywhere, inner must be non-null, however in places where
 529     * the Rust equivalent takes an Option, it may be set to null to indicate None.
 530     */
 531    LDKnativeCommitmentTransaction *inner;
 532    /**
 533     * Indicates that this is the only struct which contains the same pointer.
 534     * Rust functions which take ownership of an object provided via an argument require
 535     * this to be true and invalidate the object pointed to by inner.
 536     */
 537    bool is_owned;
 538 } LDKCommitmentTransaction;
 539
 540 typedef union LDKCResult_CommitmentTransactionDecodeErrorZPtr {
 541    struct LDKCommitmentTransaction *result;
 542    struct LDKDecodeError *err;
 543 } LDKCResult_CommitmentTransactionDecodeErrorZPtr;
 544
 545 typedef struct LDKCResult_CommitmentTransactionDecodeErrorZ {
 546    union LDKCResult_CommitmentTransactionDecodeErrorZPtr contents;
 547    bool result_ok;
 548 } LDKCResult_CommitmentTransactionDecodeErrorZ;
 549
 550
 551
 552 /**
 553  * A wrapper on CommitmentTransaction indicating that the derived fields (the built bitcoin
 554  * transaction and the transaction creation keys) are trusted.
 555  *
 556  * See trust() and verify() functions on CommitmentTransaction.
 557  *
 558  * This structure implements Deref.
 559  */
 560 typedef struct MUST_USE_STRUCT LDKTrustedCommitmentTransaction {
 561    /**
 562     * A pointer to the opaque Rust object.
 563     * Nearly everywhere, inner must be non-null, however in places where
 564     * the Rust equivalent takes an Option, it may be set to null to indicate None.
 565     */
 566    LDKnativeTrustedCommitmentTransaction *inner;
 567    /**
 568     * Indicates that this is the only struct which contains the same pointer.
 569     * Rust functions which take ownership of an object provided via an argument require
 570     * this to be true and invalidate the object pointed to by inner.
 571     */
 572    bool is_owned;
 573 } LDKTrustedCommitmentTransaction;
 574
 575 typedef union LDKCResult_TrustedCommitmentTransactionNoneZPtr {
 576    struct LDKTrustedCommitmentTransaction *result;
 577    /**
 578     * Note that this value is always NULL, as there are no contents in the Err variant
 579     */
 580    void *err;
 581 } LDKCResult_TrustedCommitmentTransactionNoneZPtr;
 582
 583 typedef struct LDKCResult_TrustedCommitmentTransactionNoneZ {
 584    union LDKCResult_TrustedCommitmentTransactionNoneZPtr contents;
 585    bool result_ok;
 586 } LDKCResult_TrustedCommitmentTransactionNoneZ;
 587
 588 typedef union LDKCResult_CVec_SignatureZNoneZPtr {
 589    struct LDKCVec_SignatureZ *result;
 590    /**
 591     * Note that this value is always NULL, as there are no contents in the Err variant
 592     */
 593    void *err;
 594 } LDKCResult_CVec_SignatureZNoneZPtr;
 595
 596 typedef struct LDKCResult_CVec_SignatureZNoneZ {
 597    union LDKCResult_CVec_SignatureZNoneZPtr contents;
 598    bool result_ok;
 599 } LDKCResult_CVec_SignatureZNoneZ;
 600
 601
 602
 603 /**
 604  * An accept_channel message to be sent or received from a peer
 605  */
 606 typedef struct MUST_USE_STRUCT LDKAcceptChannel {
 607    /**
 608     * A pointer to the opaque Rust object.
 609     * Nearly everywhere, inner must be non-null, however in places where
 610     * the Rust equivalent takes an Option, it may be set to null to indicate None.
 611     */
 612    LDKnativeAcceptChannel *inner;
 613    /**
 614     * Indicates that this is the only struct which contains the same pointer.
 615     * Rust functions which take ownership of an object provided via an argument require
 616     * this to be true and invalidate the object pointed to by inner.
 617     */
 618    bool is_owned;
 619 } LDKAcceptChannel;
 620
 621
 622
 623 /**
 624  * An open_channel message to be sent or received from a peer
 625  */
 626 typedef struct MUST_USE_STRUCT LDKOpenChannel {
 627    /**
 628     * A pointer to the opaque Rust object.
 629     * Nearly everywhere, inner must be non-null, however in places where
 630     * the Rust equivalent takes an Option, it may be set to null to indicate None.
 631     */
 632    LDKnativeOpenChannel *inner;
 633    /**
 634     * Indicates that this is the only struct which contains the same pointer.
 635     * Rust functions which take ownership of an object provided via an argument require
 636     * this to be true and invalidate the object pointed to by inner.
 637     */
 638    bool is_owned;
 639 } LDKOpenChannel;
 640
 641
 642
 643 /**
 644  * A funding_created message to be sent or received from a peer
 645  */
 646 typedef struct MUST_USE_STRUCT LDKFundingCreated {
 647    /**
 648     * A pointer to the opaque Rust object.
 649     * Nearly everywhere, inner must be non-null, however in places where
 650     * the Rust equivalent takes an Option, it may be set to null to indicate None.
 651     */
 652    LDKnativeFundingCreated *inner;
 653    /**
 654     * Indicates that this is the only struct which contains the same pointer.
 655     * Rust functions which take ownership of an object provided via an argument require
 656     * this to be true and invalidate the object pointed to by inner.
 657     */
 658    bool is_owned;
 659 } LDKFundingCreated;
 660
 661
 662
 663 /**
 664  * A funding_signed message to be sent or received from a peer
 665  */
 666 typedef struct MUST_USE_STRUCT LDKFundingSigned {
 667    /**
 668     * A pointer to the opaque Rust object.
 669     * Nearly everywhere, inner must be non-null, however in places where
 670     * the Rust equivalent takes an Option, it may be set to null to indicate None.
 671     */
 672    LDKnativeFundingSigned *inner;
 673    /**
 674     * Indicates that this is the only struct which contains the same pointer.
 675     * Rust functions which take ownership of an object provided via an argument require
 676     * this to be true and invalidate the object pointed to by inner.
 677     */
 678    bool is_owned;
 679 } LDKFundingSigned;
 680
 681
 682
 683 /**
 684  * A funding_locked message to be sent or received from a peer
 685  */
 686 typedef struct MUST_USE_STRUCT LDKFundingLocked {
 687    /**
 688     * A pointer to the opaque Rust object.
 689     * Nearly everywhere, inner must be non-null, however in places where
 690     * the Rust equivalent takes an Option, it may be set to null to indicate None.
 691     */
 692    LDKnativeFundingLocked *inner;
 693    /**
 694     * Indicates that this is the only struct which contains the same pointer.
 695     * Rust functions which take ownership of an object provided via an argument require
 696     * this to be true and invalidate the object pointed to by inner.
 697     */
 698    bool is_owned;
 699 } LDKFundingLocked;
 700
 701
 702
 703 /**
 704  * An announcement_signatures message to be sent or received from a peer
 705  */
 706 typedef struct MUST_USE_STRUCT LDKAnnouncementSignatures {
 707    /**
 708     * A pointer to the opaque Rust object.
 709     * Nearly everywhere, inner must be non-null, however in places where
 710     * the Rust equivalent takes an Option, it may be set to null to indicate None.
 711     */
 712    LDKnativeAnnouncementSignatures *inner;
 713    /**
 714     * Indicates that this is the only struct which contains the same pointer.
 715     * Rust functions which take ownership of an object provided via an argument require
 716     * this to be true and invalidate the object pointed to by inner.
 717     */
 718    bool is_owned;
 719 } LDKAnnouncementSignatures;
 720
 721
 722
 723 /**
 724  * Struct used to return values from revoke_and_ack messages, containing a bunch of commitment
 725  * transaction updates if they were pending.
 726  */
 727 typedef struct MUST_USE_STRUCT LDKCommitmentUpdate {
 728    /**
 729     * A pointer to the opaque Rust object.
 730     * Nearly everywhere, inner must be non-null, however in places where
 731     * the Rust equivalent takes an Option, it may be set to null to indicate None.
 732     */
 733    LDKnativeCommitmentUpdate *inner;
 734    /**
 735     * Indicates that this is the only struct which contains the same pointer.
 736     * Rust functions which take ownership of an object provided via an argument require
 737     * this to be true and invalidate the object pointed to by inner.
 738     */
 739    bool is_owned;
 740 } LDKCommitmentUpdate;
 741
 742
 743
 744 /**
 745  * A revoke_and_ack message to be sent or received from a peer
 746  */
 747 typedef struct MUST_USE_STRUCT LDKRevokeAndACK {
 748    /**
 749     * A pointer to the opaque Rust object.
 750     * Nearly everywhere, inner must be non-null, however in places where
 751     * the Rust equivalent takes an Option, it may be set to null to indicate None.
 752     */
 753    LDKnativeRevokeAndACK *inner;
 754    /**
 755     * Indicates that this is the only struct which contains the same pointer.
 756     * Rust functions which take ownership of an object provided via an argument require
 757     * this to be true and invalidate the object pointed to by inner.
 758     */
 759    bool is_owned;
 760 } LDKRevokeAndACK;
 761
 762
 763
 764 /**
 765  * A closing_signed message to be sent or received from a peer
 766  */
 767 typedef struct MUST_USE_STRUCT LDKClosingSigned {
 768    /**
 769     * A pointer to the opaque Rust object.
 770     * Nearly everywhere, inner must be non-null, however in places where
 771     * the Rust equivalent takes an Option, it may be set to null to indicate None.
 772     */
 773    LDKnativeClosingSigned *inner;
 774    /**
 775     * Indicates that this is the only struct which contains the same pointer.
 776     * Rust functions which take ownership of an object provided via an argument require
 777     * this to be true and invalidate the object pointed to by inner.
 778     */
 779    bool is_owned;
 780 } LDKClosingSigned;
 781
 782
 783
 784 /**
 785  * A shutdown message to be sent or received from a peer
 786  */
 787 typedef struct MUST_USE_STRUCT LDKShutdown {
 788    /**
 789     * A pointer to the opaque Rust object.
 790     * Nearly everywhere, inner must be non-null, however in places where
 791     * the Rust equivalent takes an Option, it may be set to null to indicate None.
 792     */
 793    LDKnativeShutdown *inner;
 794    /**
 795     * Indicates that this is the only struct which contains the same pointer.
 796     * Rust functions which take ownership of an object provided via an argument require
 797     * this to be true and invalidate the object pointed to by inner.
 798     */
 799    bool is_owned;
 800 } LDKShutdown;
 801
 802
 803
 804 /**
 805  * A channel_reestablish message to be sent or received from a peer
 806  */
 807 typedef struct MUST_USE_STRUCT LDKChannelReestablish {
 808    /**
 809     * A pointer to the opaque Rust object.
 810     * Nearly everywhere, inner must be non-null, however in places where
 811     * the Rust equivalent takes an Option, it may be set to null to indicate None.
 812     */
 813    LDKnativeChannelReestablish *inner;
 814    /**
 815     * Indicates that this is the only struct which contains the same pointer.
 816     * Rust functions which take ownership of an object provided via an argument require
 817     * this to be true and invalidate the object pointed to by inner.
 818     */
 819    bool is_owned;
 820 } LDKChannelReestablish;
 821
 822
 823
 824 /**
 825  * A channel_announcement message to be sent or received from a peer
 826  */
 827 typedef struct MUST_USE_STRUCT LDKChannelAnnouncement {
 828    /**
 829     * A pointer to the opaque Rust object.
 830     * Nearly everywhere, inner must be non-null, however in places where
 831     * the Rust equivalent takes an Option, it may be set to null to indicate None.
 832     */
 833    LDKnativeChannelAnnouncement *inner;
 834    /**
 835     * Indicates that this is the only struct which contains the same pointer.
 836     * Rust functions which take ownership of an object provided via an argument require
 837     * this to be true and invalidate the object pointed to by inner.
 838     */
 839    bool is_owned;
 840 } LDKChannelAnnouncement;
 841
 842
 843
 844 /**
 845  * A channel_update message to be sent or received from a peer
 846  */
 847 typedef struct MUST_USE_STRUCT LDKChannelUpdate {
 848    /**
 849     * A pointer to the opaque Rust object.
 850     * Nearly everywhere, inner must be non-null, however in places where
 851     * the Rust equivalent takes an Option, it may be set to null to indicate None.
 852     */
 853    LDKnativeChannelUpdate *inner;
 854    /**
 855     * Indicates that this is the only struct which contains the same pointer.
 856     * Rust functions which take ownership of an object provided via an argument require
 857     * this to be true and invalidate the object pointed to by inner.
 858     */
 859    bool is_owned;
 860 } LDKChannelUpdate;
 861
 862
 863
 864 /**
 865  * A node_announcement message to be sent or received from a peer
 866  */
 867 typedef struct MUST_USE_STRUCT LDKNodeAnnouncement {
 868    /**
 869     * A pointer to the opaque Rust object.
 870     * Nearly everywhere, inner must be non-null, however in places where
 871     * the Rust equivalent takes an Option, it may be set to null to indicate None.
 872     */
 873    LDKnativeNodeAnnouncement *inner;
 874    /**
 875     * Indicates that this is the only struct which contains the same pointer.
 876     * Rust functions which take ownership of an object provided via an argument require
 877     * this to be true and invalidate the object pointed to by inner.
 878     */
 879    bool is_owned;
 880 } LDKNodeAnnouncement;
 881
 882
 883
 884 /**
 885  * An error message to be sent or received from a peer
 886  */
 887 typedef struct MUST_USE_STRUCT LDKErrorMessage {
 888    /**
 889     * A pointer to the opaque Rust object.
 890     * Nearly everywhere, inner must be non-null, however in places where
 891     * the Rust equivalent takes an Option, it may be set to null to indicate None.
 892     */
 893    LDKnativeErrorMessage *inner;
 894    /**
 895     * Indicates that this is the only struct which contains the same pointer.
 896     * Rust functions which take ownership of an object provided via an argument require
 897     * this to be true and invalidate the object pointed to by inner.
 898     */
 899    bool is_owned;
 900 } LDKErrorMessage;
 901
 902 /**
 903  * Used to put an error message in a LightningError
 904  */
 905 typedef enum LDKErrorAction_Tag {
 906    /**
 907     * The peer took some action which made us think they were useless. Disconnect them.
 908     */
 909    LDKErrorAction_DisconnectPeer,
 910    /**
 911     * The peer did something harmless that we weren't able to process, just log and ignore
 912     */
 913    LDKErrorAction_IgnoreError,
 914    /**
 915     * The peer did something incorrect. Tell them.
 916     */
 917    LDKErrorAction_SendErrorMessage,
 918    /**
 919     * Must be last for serialization purposes
 920     */
 921    LDKErrorAction_Sentinel,
 922 } LDKErrorAction_Tag;
 923
 924 typedef struct LDKErrorAction_LDKDisconnectPeer_Body {
 925    /**
 926     * An error message which we should make an effort to send before we disconnect.
 927     */
 928    struct LDKErrorMessage msg;
 929 } LDKErrorAction_LDKDisconnectPeer_Body;
 930
 931 typedef struct LDKErrorAction_LDKSendErrorMessage_Body {
 932    /**
 933     * The message to send.
 934     */
 935    struct LDKErrorMessage msg;
 936 } LDKErrorAction_LDKSendErrorMessage_Body;
 937
 938 typedef struct MUST_USE_STRUCT LDKErrorAction {
 939    LDKErrorAction_Tag tag;
 940    union {
 941       LDKErrorAction_LDKDisconnectPeer_Body disconnect_peer;
 942       LDKErrorAction_LDKSendErrorMessage_Body send_error_message;
 943    };
 944 } LDKErrorAction;
 945
 946 /**
 947  * The information we received from a peer along the route of a payment we originated. This is
 948  * returned by ChannelMessageHandler::handle_update_fail_htlc to be passed into
 949  * RoutingMessageHandler::handle_htlc_fail_channel_update to update our network map.
 950  */
 951 typedef enum LDKHTLCFailChannelUpdate_Tag {
 952    /**
 953     * We received an error which included a full ChannelUpdate message.
 954     */
 955    LDKHTLCFailChannelUpdate_ChannelUpdateMessage,
 956    /**
 957     * We received an error which indicated only that a channel has been closed
 958     */
 959    LDKHTLCFailChannelUpdate_ChannelClosed,
 960    /**
 961     * We received an error which indicated only that a node has failed
 962     */
 963    LDKHTLCFailChannelUpdate_NodeFailure,
 964    /**
 965     * Must be last for serialization purposes
 966     */
 967    LDKHTLCFailChannelUpdate_Sentinel,
 968 } LDKHTLCFailChannelUpdate_Tag;
 969
 970 typedef struct LDKHTLCFailChannelUpdate_LDKChannelUpdateMessage_Body {
 971    /**
 972     * The unwrapped message we received
 973     */
 974    struct LDKChannelUpdate msg;
 975 } LDKHTLCFailChannelUpdate_LDKChannelUpdateMessage_Body;
 976
 977 typedef struct LDKHTLCFailChannelUpdate_LDKChannelClosed_Body {
 978    /**
 979     * The short_channel_id which has now closed.
 980     */
 981    uint64_t short_channel_id;
 982    /**
 983     * when this true, this channel should be permanently removed from the
 984     * consideration. Otherwise, this channel can be restored as new channel_update is received
 985     */
 986    bool is_permanent;
 987 } LDKHTLCFailChannelUpdate_LDKChannelClosed_Body;
 988
 989 typedef struct LDKHTLCFailChannelUpdate_LDKNodeFailure_Body {
 990    /**
 991     * The node_id that has failed.
 992     */
 993    struct LDKPublicKey node_id;
 994    /**
 995     * when this true, node should be permanently removed from the
 996     * consideration. Otherwise, the channels connected to this node can be
 997     * restored as new channel_update is received
 998     */
 999    bool is_permanent;
1000 } LDKHTLCFailChannelUpdate_LDKNodeFailure_Body;
1001
1002 typedef struct MUST_USE_STRUCT LDKHTLCFailChannelUpdate {
1003    LDKHTLCFailChannelUpdate_Tag tag;
1004    union {
1005       LDKHTLCFailChannelUpdate_LDKChannelUpdateMessage_Body channel_update_message;
1006       LDKHTLCFailChannelUpdate_LDKChannelClosed_Body channel_closed;
1007       LDKHTLCFailChannelUpdate_LDKNodeFailure_Body node_failure;
1008    };
1009 } LDKHTLCFailChannelUpdate;
1010
1011
1012
1013 /**
1014  * A query_channel_range message is used to query a peer for channel
1015  * UTXOs in a range of blocks. The recipient of a query makes a best
1016  * effort to reply to the query using one or more reply_channel_range
1017  * messages.
1018  */
1019 typedef struct MUST_USE_STRUCT LDKQueryChannelRange {
1020    /**
1021     * A pointer to the opaque Rust object.
1022     * Nearly everywhere, inner must be non-null, however in places where
1023     * the Rust equivalent takes an Option, it may be set to null to indicate None.
1024     */
1025    LDKnativeQueryChannelRange *inner;
1026    /**
1027     * Indicates that this is the only struct which contains the same pointer.
1028     * Rust functions which take ownership of an object provided via an argument require
1029     * this to be true and invalidate the object pointed to by inner.
1030     */
1031    bool is_owned;
1032 } LDKQueryChannelRange;
1033
1034
1035
1036 /**
1037  * A query_short_channel_ids message is used to query a peer for
1038  * routing gossip messages related to one or more short_channel_ids.
1039  * The query recipient will reply with the latest, if available,
1040  * channel_announcement, channel_update and node_announcement messages
1041  * it maintains for the requested short_channel_ids followed by a
1042  * reply_short_channel_ids_end message. The short_channel_ids sent in
1043  * this query are encoded. We only support encoding_type=0 uncompressed
1044  * serialization and do not support encoding_type=1 zlib serialization.
1045  */
1046 typedef struct MUST_USE_STRUCT LDKQueryShortChannelIds {
1047    /**
1048     * A pointer to the opaque Rust object.
1049     * Nearly everywhere, inner must be non-null, however in places where
1050     * the Rust equivalent takes an Option, it may be set to null to indicate None.
1051     */
1052    LDKnativeQueryShortChannelIds *inner;
1053    /**
1054     * Indicates that this is the only struct which contains the same pointer.
1055     * Rust functions which take ownership of an object provided via an argument require
1056     * this to be true and invalidate the object pointed to by inner.
1057     */
1058    bool is_owned;
1059 } LDKQueryShortChannelIds;
1060
1061
1062
1063 /**
1064  * A reply_channel_range message is a reply to a query_channel_range
1065  * message. Multiple reply_channel_range messages can be sent in reply
1066  * to a single query_channel_range message. The query recipient makes a
1067  * best effort to respond based on their local network view which may
1068  * not be a perfect view of the network. The short_channel_ids in the
1069  * reply are encoded. We only support encoding_type=0 uncompressed
1070  * serialization and do not support encoding_type=1 zlib serialization.
1071  */
1072 typedef struct MUST_USE_STRUCT LDKReplyChannelRange {
1073    /**
1074     * A pointer to the opaque Rust object.
1075     * Nearly everywhere, inner must be non-null, however in places where
1076     * the Rust equivalent takes an Option, it may be set to null to indicate None.
1077     */
1078    LDKnativeReplyChannelRange *inner;
1079    /**
1080     * Indicates that this is the only struct which contains the same pointer.
1081     * Rust functions which take ownership of an object provided via an argument require
1082     * this to be true and invalidate the object pointed to by inner.
1083     */
1084    bool is_owned;
1085 } LDKReplyChannelRange;
1086
1087 /**
1088  * An event generated by ChannelManager which indicates a message should be sent to a peer (or
1089  * broadcast to most peers).
1090  * These events are handled by PeerManager::process_events if you are using a PeerManager.
1091  */
1092 typedef enum LDKMessageSendEvent_Tag {
1093    /**
1094     * Used to indicate that we've accepted a channel open and should send the accept_channel
1095     * message provided to the given peer.
1096     */
1097    LDKMessageSendEvent_SendAcceptChannel,
1098    /**
1099     * Used to indicate that we've initiated a channel open and should send the open_channel
1100     * message provided to the given peer.
1101     */
1102    LDKMessageSendEvent_SendOpenChannel,
1103    /**
1104     * Used to indicate that a funding_created message should be sent to the peer with the given node_id.
1105     */
1106    LDKMessageSendEvent_SendFundingCreated,
1107    /**
1108     * Used to indicate that a funding_signed message should be sent to the peer with the given node_id.
1109     */
1110    LDKMessageSendEvent_SendFundingSigned,
1111    /**
1112     * Used to indicate that a funding_locked message should be sent to the peer with the given node_id.
1113     */
1114    LDKMessageSendEvent_SendFundingLocked,
1115    /**
1116     * Used to indicate that an announcement_signatures message should be sent to the peer with the given node_id.
1117     */
1118    LDKMessageSendEvent_SendAnnouncementSignatures,
1119    /**
1120     * Used to indicate that a series of HTLC update messages, as well as a commitment_signed
1121     * message should be sent to the peer with the given node_id.
1122     */
1123    LDKMessageSendEvent_UpdateHTLCs,
1124    /**
1125     * Used to indicate that a revoke_and_ack message should be sent to the peer with the given node_id.
1126     */
1127    LDKMessageSendEvent_SendRevokeAndACK,
1128    /**
1129     * Used to indicate that a closing_signed message should be sent to the peer with the given node_id.
1130     */
1131    LDKMessageSendEvent_SendClosingSigned,
1132    /**
1133     * Used to indicate that a shutdown message should be sent to the peer with the given node_id.
1134     */
1135    LDKMessageSendEvent_SendShutdown,
1136    /**
1137     * Used to indicate that a channel_reestablish message should be sent to the peer with the given node_id.
1138     */
1139    LDKMessageSendEvent_SendChannelReestablish,
1140    /**
1141     * Used to indicate that a channel_announcement and channel_update should be broadcast to all
1142     * peers (except the peer with node_id either msg.contents.node_id_1 or msg.contents.node_id_2).
1143     *
1144     * Note that after doing so, you very likely (unless you did so very recently) want to call
1145     * ChannelManager::broadcast_node_announcement to trigger a BroadcastNodeAnnouncement event.
1146     * This ensures that any nodes which see our channel_announcement also have a relevant
1147     * node_announcement, including relevant feature flags which may be important for routing
1148     * through or to us.
1149     */
1150    LDKMessageSendEvent_BroadcastChannelAnnouncement,
1151    /**
1152     * Used to indicate that a node_announcement should be broadcast to all peers.
1153     */
1154    LDKMessageSendEvent_BroadcastNodeAnnouncement,
1155    /**
1156     * Used to indicate that a channel_update should be broadcast to all peers.
1157     */
1158    LDKMessageSendEvent_BroadcastChannelUpdate,
1159    /**
1160     * Broadcast an error downstream to be handled
1161     */
1162    LDKMessageSendEvent_HandleError,
1163    /**
1164     * When a payment fails we may receive updates back from the hop where it failed. In such
1165     * cases this event is generated so that we can inform the network graph of this information.
1166     */
1167    LDKMessageSendEvent_PaymentFailureNetworkUpdate,
1168    /**
1169     * Query a peer for channels with funding transaction UTXOs in a block range.
1170     */
1171    LDKMessageSendEvent_SendChannelRangeQuery,
1172    /**
1173     * Request routing gossip messages from a peer for a list of channels identified by
1174     * their short_channel_ids.
1175     */
1176    LDKMessageSendEvent_SendShortIdsQuery,
1177    /**
1178     * Sends a reply to a channel range query. This may be one of several SendReplyChannelRange events
1179     * emitted during processing of the query.
1180     */
1181    LDKMessageSendEvent_SendReplyChannelRange,
1182    /**
1183     * Must be last for serialization purposes
1184     */
1185    LDKMessageSendEvent_Sentinel,
1186 } LDKMessageSendEvent_Tag;
1187
1188 typedef struct LDKMessageSendEvent_LDKSendAcceptChannel_Body {
1189    /**
1190     * The node_id of the node which should receive this message
1191     */
1192    struct LDKPublicKey node_id;
1193    /**
1194     * The message which should be sent.
1195     */
1196    struct LDKAcceptChannel msg;
1197 } LDKMessageSendEvent_LDKSendAcceptChannel_Body;
1198
1199 typedef struct LDKMessageSendEvent_LDKSendOpenChannel_Body {
1200    /**
1201     * The node_id of the node which should receive this message
1202     */
1203    struct LDKPublicKey node_id;
1204    /**
1205     * The message which should be sent.
1206     */
1207    struct LDKOpenChannel msg;
1208 } LDKMessageSendEvent_LDKSendOpenChannel_Body;
1209
1210 typedef struct LDKMessageSendEvent_LDKSendFundingCreated_Body {
1211    /**
1212     * The node_id of the node which should receive this message
1213     */
1214    struct LDKPublicKey node_id;
1215    /**
1216     * The message which should be sent.
1217     */
1218    struct LDKFundingCreated msg;
1219 } LDKMessageSendEvent_LDKSendFundingCreated_Body;
1220
1221 typedef struct LDKMessageSendEvent_LDKSendFundingSigned_Body {
1222    /**
1223     * The node_id of the node which should receive this message
1224     */
1225    struct LDKPublicKey node_id;
1226    /**
1227     * The message which should be sent.
1228     */
1229    struct LDKFundingSigned msg;
1230 } LDKMessageSendEvent_LDKSendFundingSigned_Body;
1231
1232 typedef struct LDKMessageSendEvent_LDKSendFundingLocked_Body {
1233    /**
1234     * The node_id of the node which should receive these message(s)
1235     */
1236    struct LDKPublicKey node_id;
1237    /**
1238     * The funding_locked message which should be sent.
1239     */
1240    struct LDKFundingLocked msg;
1241 } LDKMessageSendEvent_LDKSendFundingLocked_Body;
1242
1243 typedef struct LDKMessageSendEvent_LDKSendAnnouncementSignatures_Body {
1244    /**
1245     * The node_id of the node which should receive these message(s)
1246     */
1247    struct LDKPublicKey node_id;
1248    /**
1249     * The announcement_signatures message which should be sent.
1250     */
1251    struct LDKAnnouncementSignatures msg;
1252 } LDKMessageSendEvent_LDKSendAnnouncementSignatures_Body;
1253
1254 typedef struct LDKMessageSendEvent_LDKUpdateHTLCs_Body {
1255    /**
1256     * The node_id of the node which should receive these message(s)
1257     */
1258    struct LDKPublicKey node_id;
1259    /**
1260     * The update messages which should be sent. ALL messages in the struct should be sent!
1261     */
1262    struct LDKCommitmentUpdate updates;
1263 } LDKMessageSendEvent_LDKUpdateHTLCs_Body;
1264
1265 typedef struct LDKMessageSendEvent_LDKSendRevokeAndACK_Body {
1266    /**
1267     * The node_id of the node which should receive this message
1268     */
1269    struct LDKPublicKey node_id;
1270    /**
1271     * The message which should be sent.
1272     */
1273    struct LDKRevokeAndACK msg;
1274 } LDKMessageSendEvent_LDKSendRevokeAndACK_Body;
1275
1276 typedef struct LDKMessageSendEvent_LDKSendClosingSigned_Body {
1277    /**
1278     * The node_id of the node which should receive this message
1279     */
1280    struct LDKPublicKey node_id;
1281    /**
1282     * The message which should be sent.
1283     */
1284    struct LDKClosingSigned msg;
1285 } LDKMessageSendEvent_LDKSendClosingSigned_Body;
1286
1287 typedef struct LDKMessageSendEvent_LDKSendShutdown_Body {
1288    /**
1289     * The node_id of the node which should receive this message
1290     */
1291    struct LDKPublicKey node_id;
1292    /**
1293     * The message which should be sent.
1294     */
1295    struct LDKShutdown msg;
1296 } LDKMessageSendEvent_LDKSendShutdown_Body;
1297
1298 typedef struct LDKMessageSendEvent_LDKSendChannelReestablish_Body {
1299    /**
1300     * The node_id of the node which should receive this message
1301     */
1302    struct LDKPublicKey node_id;
1303    /**
1304     * The message which should be sent.
1305     */
1306    struct LDKChannelReestablish msg;
1307 } LDKMessageSendEvent_LDKSendChannelReestablish_Body;
1308
1309 typedef struct LDKMessageSendEvent_LDKBroadcastChannelAnnouncement_Body {
1310    /**
1311     * The channel_announcement which should be sent.
1312     */
1313    struct LDKChannelAnnouncement msg;
1314    /**
1315     * The followup channel_update which should be sent.
1316     */
1317    struct LDKChannelUpdate update_msg;
1318 } LDKMessageSendEvent_LDKBroadcastChannelAnnouncement_Body;
1319
1320 typedef struct LDKMessageSendEvent_LDKBroadcastNodeAnnouncement_Body {
1321    /**
1322     * The node_announcement which should be sent.
1323     */
1324    struct LDKNodeAnnouncement msg;
1325 } LDKMessageSendEvent_LDKBroadcastNodeAnnouncement_Body;
1326
1327 typedef struct LDKMessageSendEvent_LDKBroadcastChannelUpdate_Body {
1328    /**
1329     * The channel_update which should be sent.
1330     */
1331    struct LDKChannelUpdate msg;
1332 } LDKMessageSendEvent_LDKBroadcastChannelUpdate_Body;
1333
1334 typedef struct LDKMessageSendEvent_LDKHandleError_Body {
1335    /**
1336     * The node_id of the node which should receive this message
1337     */
1338    struct LDKPublicKey node_id;
1339    /**
1340     * The action which should be taken.
1341     */
1342    struct LDKErrorAction action;
1343 } LDKMessageSendEvent_LDKHandleError_Body;
1344
1345 typedef struct LDKMessageSendEvent_LDKPaymentFailureNetworkUpdate_Body {
1346    /**
1347     * The channel/node update which should be sent to NetGraphMsgHandler
1348     */
1349    struct LDKHTLCFailChannelUpdate update;
1350 } LDKMessageSendEvent_LDKPaymentFailureNetworkUpdate_Body;
1351
1352 typedef struct LDKMessageSendEvent_LDKSendChannelRangeQuery_Body {
1353    /**
1354     * The node_id of this message recipient
1355     */
1356    struct LDKPublicKey node_id;
1357    /**
1358     * The query_channel_range which should be sent.
1359     */
1360    struct LDKQueryChannelRange msg;
1361 } LDKMessageSendEvent_LDKSendChannelRangeQuery_Body;
1362
1363 typedef struct LDKMessageSendEvent_LDKSendShortIdsQuery_Body {
1364    /**
1365     * The node_id of this message recipient
1366     */
1367    struct LDKPublicKey node_id;
1368    /**
1369     * The query_short_channel_ids which should be sent.
1370     */
1371    struct LDKQueryShortChannelIds msg;
1372 } LDKMessageSendEvent_LDKSendShortIdsQuery_Body;
1373
1374 typedef struct LDKMessageSendEvent_LDKSendReplyChannelRange_Body {
1375    /**
1376     * The node_id of this message recipient
1377     */
1378    struct LDKPublicKey node_id;
1379    /**
1380     * The reply_channel_range which should be sent.
1381     */
1382    struct LDKReplyChannelRange msg;
1383 } LDKMessageSendEvent_LDKSendReplyChannelRange_Body;
1384
1385 typedef struct MUST_USE_STRUCT LDKMessageSendEvent {
1386    LDKMessageSendEvent_Tag tag;
1387    union {
1388       LDKMessageSendEvent_LDKSendAcceptChannel_Body send_accept_channel;
1389       LDKMessageSendEvent_LDKSendOpenChannel_Body send_open_channel;
1390       LDKMessageSendEvent_LDKSendFundingCreated_Body send_funding_created;
1391       LDKMessageSendEvent_LDKSendFundingSigned_Body send_funding_signed;
1392       LDKMessageSendEvent_LDKSendFundingLocked_Body send_funding_locked;
1393       LDKMessageSendEvent_LDKSendAnnouncementSignatures_Body send_announcement_signatures;
1394       LDKMessageSendEvent_LDKUpdateHTLCs_Body update_htl_cs;
1395       LDKMessageSendEvent_LDKSendRevokeAndACK_Body send_revoke_and_ack;
1396       LDKMessageSendEvent_LDKSendClosingSigned_Body send_closing_signed;
1397       LDKMessageSendEvent_LDKSendShutdown_Body send_shutdown;
1398       LDKMessageSendEvent_LDKSendChannelReestablish_Body send_channel_reestablish;
1399       LDKMessageSendEvent_LDKBroadcastChannelAnnouncement_Body broadcast_channel_announcement;
1400       LDKMessageSendEvent_LDKBroadcastNodeAnnouncement_Body broadcast_node_announcement;
1401       LDKMessageSendEvent_LDKBroadcastChannelUpdate_Body broadcast_channel_update;
1402       LDKMessageSendEvent_LDKHandleError_Body handle_error;
1403       LDKMessageSendEvent_LDKPaymentFailureNetworkUpdate_Body payment_failure_network_update;
1404       LDKMessageSendEvent_LDKSendChannelRangeQuery_Body send_channel_range_query;
1405       LDKMessageSendEvent_LDKSendShortIdsQuery_Body send_short_ids_query;
1406       LDKMessageSendEvent_LDKSendReplyChannelRange_Body send_reply_channel_range;
1407    };
1408 } LDKMessageSendEvent;
1409
1410 typedef struct LDKCVec_MessageSendEventZ {
1411    struct LDKMessageSendEvent *data;
1412    uintptr_t datalen;
1413 } LDKCVec_MessageSendEventZ;
1414
1415
1416
1417 /**
1418  * An Err type for failure to process messages.
1419  */
1420 typedef struct MUST_USE_STRUCT LDKLightningError {
1421    /**
1422     * A pointer to the opaque Rust object.
1423     * Nearly everywhere, inner must be non-null, however in places where
1424     * the Rust equivalent takes an Option, it may be set to null to indicate None.
1425     */
1426    LDKnativeLightningError *inner;
1427    /**
1428     * Indicates that this is the only struct which contains the same pointer.
1429     * Rust functions which take ownership of an object provided via an argument require
1430     * this to be true and invalidate the object pointed to by inner.
1431     */
1432    bool is_owned;
1433 } LDKLightningError;
1434
1435 typedef union LDKCResult_boolLightningErrorZPtr {
1436    bool *result;
1437    struct LDKLightningError *err;
1438 } LDKCResult_boolLightningErrorZPtr;
1439
1440 typedef struct LDKCResult_boolLightningErrorZ {
1441    union LDKCResult_boolLightningErrorZPtr contents;
1442    bool result_ok;
1443 } LDKCResult_boolLightningErrorZ;
1444
1445 typedef struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ {
1446    struct LDKChannelAnnouncement a;
1447    struct LDKChannelUpdate b;
1448    struct LDKChannelUpdate c;
1449 } LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ;
1450
1451 typedef struct LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
1452    struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *data;
1453    uintptr_t datalen;
1454 } LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ;
1455
1456 typedef struct LDKCVec_NodeAnnouncementZ {
1457    struct LDKNodeAnnouncement *data;
1458    uintptr_t datalen;
1459 } LDKCVec_NodeAnnouncementZ;
1460
1461 typedef union LDKCResult_NoneLightningErrorZPtr {
1462    /**
1463     * Note that this value is always NULL, as there are no contents in the OK variant
1464     */
1465    void *result;
1466    struct LDKLightningError *err;
1467 } LDKCResult_NoneLightningErrorZPtr;
1468
1469 typedef struct LDKCResult_NoneLightningErrorZ {
1470    union LDKCResult_NoneLightningErrorZPtr contents;
1471    bool result_ok;
1472 } LDKCResult_NoneLightningErrorZ;
1473
1474 typedef struct LDKCVec_PublicKeyZ {
1475    struct LDKPublicKey *data;
1476    uintptr_t datalen;
1477 } LDKCVec_PublicKeyZ;
1478
1479
1480
1481 /**
1482  * Error for PeerManager errors. If you get one of these, you must disconnect the socket and
1483  * generate no further read_event/write_buffer_space_avail/socket_disconnected calls for the
1484  * descriptor.
1485  */
1486 typedef struct MUST_USE_STRUCT LDKPeerHandleError {
1487    /**
1488     * A pointer to the opaque Rust object.
1489     * Nearly everywhere, inner must be non-null, however in places where
1490     * the Rust equivalent takes an Option, it may be set to null to indicate None.
1491     */
1492    LDKnativePeerHandleError *inner;
1493    /**
1494     * Indicates that this is the only struct which contains the same pointer.
1495     * Rust functions which take ownership of an object provided via an argument require
1496     * this to be true and invalidate the object pointed to by inner.
1497     */
1498    bool is_owned;
1499 } LDKPeerHandleError;
1500
1501 typedef union LDKCResult_CVec_u8ZPeerHandleErrorZPtr {
1502    struct LDKCVec_u8Z *result;
1503    struct LDKPeerHandleError *err;
1504 } LDKCResult_CVec_u8ZPeerHandleErrorZPtr;
1505
1506 typedef struct LDKCResult_CVec_u8ZPeerHandleErrorZ {
1507    union LDKCResult_CVec_u8ZPeerHandleErrorZPtr contents;
1508    bool result_ok;
1509 } LDKCResult_CVec_u8ZPeerHandleErrorZ;
1510
1511 typedef union LDKCResult_NonePeerHandleErrorZPtr {
1512    /**
1513     * Note that this value is always NULL, as there are no contents in the OK variant
1514     */
1515    void *result;
1516    struct LDKPeerHandleError *err;
1517 } LDKCResult_NonePeerHandleErrorZPtr;
1518
1519 typedef struct LDKCResult_NonePeerHandleErrorZ {
1520    union LDKCResult_NonePeerHandleErrorZPtr contents;
1521    bool result_ok;
1522 } LDKCResult_NonePeerHandleErrorZ;
1523
1524 typedef union LDKCResult_boolPeerHandleErrorZPtr {
1525    bool *result;
1526    struct LDKPeerHandleError *err;
1527 } LDKCResult_boolPeerHandleErrorZPtr;
1528
1529 typedef struct LDKCResult_boolPeerHandleErrorZ {
1530    union LDKCResult_boolPeerHandleErrorZPtr contents;
1531    bool result_ok;
1532 } LDKCResult_boolPeerHandleErrorZ;
1533
1534
1535
1536 /**
1537  * Features used within an `init` message.
1538  */
1539 typedef struct MUST_USE_STRUCT LDKInitFeatures {
1540    /**
1541     * A pointer to the opaque Rust object.
1542     * Nearly everywhere, inner must be non-null, however in places where
1543     * the Rust equivalent takes an Option, it may be set to null to indicate None.
1544     */
1545    LDKnativeInitFeatures *inner;
1546    /**
1547     * Indicates that this is the only struct which contains the same pointer.
1548     * Rust functions which take ownership of an object provided via an argument require
1549     * this to be true and invalidate the object pointed to by inner.
1550     */
1551    bool is_owned;
1552 } LDKInitFeatures;
1553
1554 typedef union LDKCResult_InitFeaturesDecodeErrorZPtr {
1555    struct LDKInitFeatures *result;
1556    struct LDKDecodeError *err;
1557 } LDKCResult_InitFeaturesDecodeErrorZPtr;
1558
1559 typedef struct LDKCResult_InitFeaturesDecodeErrorZ {
1560    union LDKCResult_InitFeaturesDecodeErrorZPtr contents;
1561    bool result_ok;
1562 } LDKCResult_InitFeaturesDecodeErrorZ;
1563
1564
1565
1566 /**
1567  * Features used within a `node_announcement` message.
1568  */
1569 typedef struct MUST_USE_STRUCT LDKNodeFeatures {
1570    /**
1571     * A pointer to the opaque Rust object.
1572     * Nearly everywhere, inner must be non-null, however in places where
1573     * the Rust equivalent takes an Option, it may be set to null to indicate None.
1574     */
1575    LDKnativeNodeFeatures *inner;
1576    /**
1577     * Indicates that this is the only struct which contains the same pointer.
1578     * Rust functions which take ownership of an object provided via an argument require
1579     * this to be true and invalidate the object pointed to by inner.
1580     */
1581    bool is_owned;
1582 } LDKNodeFeatures;
1583
1584 typedef union LDKCResult_NodeFeaturesDecodeErrorZPtr {
1585    struct LDKNodeFeatures *result;
1586    struct LDKDecodeError *err;
1587 } LDKCResult_NodeFeaturesDecodeErrorZPtr;
1588
1589 typedef struct LDKCResult_NodeFeaturesDecodeErrorZ {
1590    union LDKCResult_NodeFeaturesDecodeErrorZPtr contents;
1591    bool result_ok;
1592 } LDKCResult_NodeFeaturesDecodeErrorZ;
1593
1594
1595
1596 /**
1597  * Features used within a `channel_announcement` message.
1598  */
1599 typedef struct MUST_USE_STRUCT LDKChannelFeatures {
1600    /**
1601     * A pointer to the opaque Rust object.
1602     * Nearly everywhere, inner must be non-null, however in places where
1603     * the Rust equivalent takes an Option, it may be set to null to indicate None.
1604     */
1605    LDKnativeChannelFeatures *inner;
1606    /**
1607     * Indicates that this is the only struct which contains the same pointer.
1608     * Rust functions which take ownership of an object provided via an argument require
1609     * this to be true and invalidate the object pointed to by inner.
1610     */
1611    bool is_owned;
1612 } LDKChannelFeatures;
1613
1614 typedef union LDKCResult_ChannelFeaturesDecodeErrorZPtr {
1615    struct LDKChannelFeatures *result;
1616    struct LDKDecodeError *err;
1617 } LDKCResult_ChannelFeaturesDecodeErrorZPtr;
1618
1619 typedef struct LDKCResult_ChannelFeaturesDecodeErrorZ {
1620    union LDKCResult_ChannelFeaturesDecodeErrorZPtr contents;
1621    bool result_ok;
1622 } LDKCResult_ChannelFeaturesDecodeErrorZ;
1623
1624
1625
1626 /**
1627  * Features used within an invoice.
1628  */
1629 typedef struct MUST_USE_STRUCT LDKInvoiceFeatures {
1630    /**
1631     * A pointer to the opaque Rust object.
1632     * Nearly everywhere, inner must be non-null, however in places where
1633     * the Rust equivalent takes an Option, it may be set to null to indicate None.
1634     */
1635    LDKnativeInvoiceFeatures *inner;
1636    /**
1637     * Indicates that this is the only struct which contains the same pointer.
1638     * Rust functions which take ownership of an object provided via an argument require
1639     * this to be true and invalidate the object pointed to by inner.
1640     */
1641    bool is_owned;
1642 } LDKInvoiceFeatures;
1643
1644 typedef union LDKCResult_InvoiceFeaturesDecodeErrorZPtr {
1645    struct LDKInvoiceFeatures *result;
1646    struct LDKDecodeError *err;
1647 } LDKCResult_InvoiceFeaturesDecodeErrorZPtr;
1648
1649 typedef struct LDKCResult_InvoiceFeaturesDecodeErrorZ {
1650    union LDKCResult_InvoiceFeaturesDecodeErrorZPtr contents;
1651    bool result_ok;
1652 } LDKCResult_InvoiceFeaturesDecodeErrorZ;
1653
1654
1655
1656 /**
1657  * Options which apply on a per-channel basis and may change at runtime or based on negotiation
1658  * with our counterparty.
1659  */
1660 typedef struct MUST_USE_STRUCT LDKChannelConfig {
1661    /**
1662     * A pointer to the opaque Rust object.
1663     * Nearly everywhere, inner must be non-null, however in places where
1664     * the Rust equivalent takes an Option, it may be set to null to indicate None.
1665     */
1666    LDKnativeChannelConfig *inner;
1667    /**
1668     * Indicates that this is the only struct which contains the same pointer.
1669     * Rust functions which take ownership of an object provided via an argument require
1670     * this to be true and invalidate the object pointed to by inner.
1671     */
1672    bool is_owned;
1673 } LDKChannelConfig;
1674
1675 typedef union LDKCResult_ChannelConfigDecodeErrorZPtr {
1676    struct LDKChannelConfig *result;
1677    struct LDKDecodeError *err;
1678 } LDKCResult_ChannelConfigDecodeErrorZPtr;
1679
1680 typedef struct LDKCResult_ChannelConfigDecodeErrorZ {
1681    union LDKCResult_ChannelConfigDecodeErrorZPtr contents;
1682    bool result_ok;
1683 } LDKCResult_ChannelConfigDecodeErrorZ;
1684
1685
1686
1687 /**
1688  * Details about one direction of a channel. Received
1689  * within a channel update.
1690  */
1691 typedef struct MUST_USE_STRUCT LDKDirectionalChannelInfo {
1692    /**
1693     * A pointer to the opaque Rust object.
1694     * Nearly everywhere, inner must be non-null, however in places where
1695     * the Rust equivalent takes an Option, it may be set to null to indicate None.
1696     */
1697    LDKnativeDirectionalChannelInfo *inner;
1698    /**
1699     * Indicates that this is the only struct which contains the same pointer.
1700     * Rust functions which take ownership of an object provided via an argument require
1701     * this to be true and invalidate the object pointed to by inner.
1702     */
1703    bool is_owned;
1704 } LDKDirectionalChannelInfo;
1705
1706 typedef union LDKCResult_DirectionalChannelInfoDecodeErrorZPtr {
1707    struct LDKDirectionalChannelInfo *result;
1708    struct LDKDecodeError *err;
1709 } LDKCResult_DirectionalChannelInfoDecodeErrorZPtr;
1710
1711 typedef struct LDKCResult_DirectionalChannelInfoDecodeErrorZ {
1712    union LDKCResult_DirectionalChannelInfoDecodeErrorZPtr contents;
1713    bool result_ok;
1714 } LDKCResult_DirectionalChannelInfoDecodeErrorZ;
1715
1716
1717
1718 /**
1719  * Details about a channel (both directions).
1720  * Received within a channel announcement.
1721  */
1722 typedef struct MUST_USE_STRUCT LDKChannelInfo {
1723    /**
1724     * A pointer to the opaque Rust object.
1725     * Nearly everywhere, inner must be non-null, however in places where
1726     * the Rust equivalent takes an Option, it may be set to null to indicate None.
1727     */
1728    LDKnativeChannelInfo *inner;
1729    /**
1730     * Indicates that this is the only struct which contains the same pointer.
1731     * Rust functions which take ownership of an object provided via an argument require
1732     * this to be true and invalidate the object pointed to by inner.
1733     */
1734    bool is_owned;
1735 } LDKChannelInfo;
1736
1737 typedef union LDKCResult_ChannelInfoDecodeErrorZPtr {
1738    struct LDKChannelInfo *result;
1739    struct LDKDecodeError *err;
1740 } LDKCResult_ChannelInfoDecodeErrorZPtr;
1741
1742 typedef struct LDKCResult_ChannelInfoDecodeErrorZ {
1743    union LDKCResult_ChannelInfoDecodeErrorZPtr contents;
1744    bool result_ok;
1745 } LDKCResult_ChannelInfoDecodeErrorZ;
1746
1747
1748
1749 /**
1750  * Fees for routing via a given channel or a node
1751  */
1752 typedef struct MUST_USE_STRUCT LDKRoutingFees {
1753    /**
1754     * A pointer to the opaque Rust object.
1755     * Nearly everywhere, inner must be non-null, however in places where
1756     * the Rust equivalent takes an Option, it may be set to null to indicate None.
1757     */
1758    LDKnativeRoutingFees *inner;
1759    /**
1760     * Indicates that this is the only struct which contains the same pointer.
1761     * Rust functions which take ownership of an object provided via an argument require
1762     * this to be true and invalidate the object pointed to by inner.
1763     */
1764    bool is_owned;
1765 } LDKRoutingFees;
1766
1767 typedef union LDKCResult_RoutingFeesDecodeErrorZPtr {
1768    struct LDKRoutingFees *result;
1769    struct LDKDecodeError *err;
1770 } LDKCResult_RoutingFeesDecodeErrorZPtr;
1771
1772 typedef struct LDKCResult_RoutingFeesDecodeErrorZ {
1773    union LDKCResult_RoutingFeesDecodeErrorZPtr contents;
1774    bool result_ok;
1775 } LDKCResult_RoutingFeesDecodeErrorZ;
1776
1777 typedef struct LDKFourBytes {
1778    uint8_t data[4];
1779 } LDKFourBytes;
1780
1781 typedef struct LDKSixteenBytes {
1782    uint8_t data[16];
1783 } LDKSixteenBytes;
1784
1785 typedef struct LDKTenBytes {
1786    uint8_t data[10];
1787 } LDKTenBytes;
1788
1789 /**
1790  * Arbitrary 32 bytes, which could represent one of a few different things. You probably want to
1791  * look up the corresponding function in rust-lightning's docs.
1792  */
1793 typedef struct LDKThirtyTwoBytes {
1794    uint8_t data[32];
1795 } LDKThirtyTwoBytes;
1796
1797 /**
1798  * An address which can be used to connect to a remote peer
1799  */
1800 typedef enum LDKNetAddress_Tag {
1801    /**
1802     * An IPv4 address/port on which the peer is listening.
1803     */
1804    LDKNetAddress_IPv4,
1805    /**
1806     * An IPv6 address/port on which the peer is listening.
1807     */
1808    LDKNetAddress_IPv6,
1809    /**
1810     * An old-style Tor onion address/port on which the peer is listening.
1811     */
1812    LDKNetAddress_OnionV2,
1813    /**
1814     * A new-style Tor onion address/port on which the peer is listening.
1815     * To create the human-readable \"hostname\", concatenate ed25519_pubkey, checksum, and version,
1816     * wrap as base32 and append \".onion\".
1817     */
1818    LDKNetAddress_OnionV3,
1819    /**
1820     * Must be last for serialization purposes
1821     */
1822    LDKNetAddress_Sentinel,
1823 } LDKNetAddress_Tag;
1824
1825 typedef struct LDKNetAddress_LDKIPv4_Body {
1826    /**
1827     * The 4-byte IPv4 address
1828     */
1829    struct LDKFourBytes addr;
1830    /**
1831     * The port on which the node is listening
1832     */
1833    uint16_t port;
1834 } LDKNetAddress_LDKIPv4_Body;
1835
1836 typedef struct LDKNetAddress_LDKIPv6_Body {
1837    /**
1838     * The 16-byte IPv6 address
1839     */
1840    struct LDKSixteenBytes addr;
1841    /**
1842     * The port on which the node is listening
1843     */
1844    uint16_t port;
1845 } LDKNetAddress_LDKIPv6_Body;
1846
1847 typedef struct LDKNetAddress_LDKOnionV2_Body {
1848    /**
1849     * The bytes (usually encoded in base32 with \".onion\" appended)
1850     */
1851    struct LDKTenBytes addr;
1852    /**
1853     * The port on which the node is listening
1854     */
1855    uint16_t port;
1856 } LDKNetAddress_LDKOnionV2_Body;
1857
1858 typedef struct LDKNetAddress_LDKOnionV3_Body {
1859    /**
1860     * The ed25519 long-term public key of the peer
1861     */
1862    struct LDKThirtyTwoBytes ed25519_pubkey;
1863    /**
1864     * The checksum of the pubkey and version, as included in the onion address
1865     */
1866    uint16_t checksum;
1867    /**
1868     * The version byte, as defined by the Tor Onion v3 spec.
1869     */
1870    uint8_t version;
1871    /**
1872     * The port on which the node is listening
1873     */
1874    uint16_t port;
1875 } LDKNetAddress_LDKOnionV3_Body;
1876
1877 typedef struct MUST_USE_STRUCT LDKNetAddress {
1878    LDKNetAddress_Tag tag;
1879    union {
1880       LDKNetAddress_LDKIPv4_Body i_pv4;
1881       LDKNetAddress_LDKIPv6_Body i_pv6;
1882       LDKNetAddress_LDKOnionV2_Body onion_v2;
1883       LDKNetAddress_LDKOnionV3_Body onion_v3;
1884    };
1885 } LDKNetAddress;
1886
1887 typedef struct LDKCVec_NetAddressZ {
1888    struct LDKNetAddress *data;
1889    uintptr_t datalen;
1890 } LDKCVec_NetAddressZ;
1891
1892
1893
1894 /**
1895  * Information received in the latest node_announcement from this node.
1896  */
1897 typedef struct MUST_USE_STRUCT LDKNodeAnnouncementInfo {
1898    /**
1899     * A pointer to the opaque Rust object.
1900     * Nearly everywhere, inner must be non-null, however in places where
1901     * the Rust equivalent takes an Option, it may be set to null to indicate None.
1902     */
1903    LDKnativeNodeAnnouncementInfo *inner;
1904    /**
1905     * Indicates that this is the only struct which contains the same pointer.
1906     * Rust functions which take ownership of an object provided via an argument require
1907     * this to be true and invalidate the object pointed to by inner.
1908     */
1909    bool is_owned;
1910 } LDKNodeAnnouncementInfo;
1911
1912 typedef union LDKCResult_NodeAnnouncementInfoDecodeErrorZPtr {
1913    struct LDKNodeAnnouncementInfo *result;
1914    struct LDKDecodeError *err;
1915 } LDKCResult_NodeAnnouncementInfoDecodeErrorZPtr;
1916
1917 typedef struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ {
1918    union LDKCResult_NodeAnnouncementInfoDecodeErrorZPtr contents;
1919    bool result_ok;
1920 } LDKCResult_NodeAnnouncementInfoDecodeErrorZ;
1921
1922 typedef struct LDKCVec_u64Z {
1923    uint64_t *data;
1924    uintptr_t datalen;
1925 } LDKCVec_u64Z;
1926
1927
1928
1929 /**
1930  * Details about a node in the network, known from the network announcement.
1931  */
1932 typedef struct MUST_USE_STRUCT LDKNodeInfo {
1933    /**
1934     * A pointer to the opaque Rust object.
1935     * Nearly everywhere, inner must be non-null, however in places where
1936     * the Rust equivalent takes an Option, it may be set to null to indicate None.
1937     */
1938    LDKnativeNodeInfo *inner;
1939    /**
1940     * Indicates that this is the only struct which contains the same pointer.
1941     * Rust functions which take ownership of an object provided via an argument require
1942     * this to be true and invalidate the object pointed to by inner.
1943     */
1944    bool is_owned;
1945 } LDKNodeInfo;
1946
1947 typedef union LDKCResult_NodeInfoDecodeErrorZPtr {
1948    struct LDKNodeInfo *result;
1949    struct LDKDecodeError *err;
1950 } LDKCResult_NodeInfoDecodeErrorZPtr;
1951
1952 typedef struct LDKCResult_NodeInfoDecodeErrorZ {
1953    union LDKCResult_NodeInfoDecodeErrorZPtr contents;
1954    bool result_ok;
1955 } LDKCResult_NodeInfoDecodeErrorZ;
1956
1957
1958
1959 /**
1960  * Represents the network as nodes and channels between them
1961  */
1962 typedef struct MUST_USE_STRUCT LDKNetworkGraph {
1963    /**
1964     * A pointer to the opaque Rust object.
1965     * Nearly everywhere, inner must be non-null, however in places where
1966     * the Rust equivalent takes an Option, it may be set to null to indicate None.
1967     */
1968    LDKnativeNetworkGraph *inner;
1969    /**
1970     * Indicates that this is the only struct which contains the same pointer.
1971     * Rust functions which take ownership of an object provided via an argument require
1972     * this to be true and invalidate the object pointed to by inner.
1973     */
1974    bool is_owned;
1975 } LDKNetworkGraph;
1976
1977 typedef union LDKCResult_NetworkGraphDecodeErrorZPtr {
1978    struct LDKNetworkGraph *result;
1979    struct LDKDecodeError *err;
1980 } LDKCResult_NetworkGraphDecodeErrorZPtr;
1981
1982 typedef struct LDKCResult_NetworkGraphDecodeErrorZ {
1983    union LDKCResult_NetworkGraphDecodeErrorZPtr contents;
1984    bool result_ok;
1985 } LDKCResult_NetworkGraphDecodeErrorZ;
1986
1987 typedef struct LDKC2Tuple_usizeTransactionZ {
1988    uintptr_t a;
1989    struct LDKTransaction b;
1990 } LDKC2Tuple_usizeTransactionZ;
1991
1992 typedef struct LDKCVec_C2Tuple_usizeTransactionZZ {
1993    struct LDKC2Tuple_usizeTransactionZ *data;
1994    uintptr_t datalen;
1995 } LDKCVec_C2Tuple_usizeTransactionZZ;
1996
1997 typedef union LDKCResult_NoneChannelMonitorUpdateErrZPtr {
1998    /**
1999     * Note that this value is always NULL, as there are no contents in the OK variant
2000     */
2001    void *result;
2002    enum LDKChannelMonitorUpdateErr *err;
2003 } LDKCResult_NoneChannelMonitorUpdateErrZPtr;
2004
2005 typedef struct LDKCResult_NoneChannelMonitorUpdateErrZ {
2006    union LDKCResult_NoneChannelMonitorUpdateErrZPtr contents;
2007    bool result_ok;
2008 } LDKCResult_NoneChannelMonitorUpdateErrZ;
2009
2010
2011
2012 /**
2013  * Simple structure sent back by `chain::Watch` when an HTLC from a forward channel is detected on
2014  * chain. Used to update the corresponding HTLC in the backward channel. Failing to pass the
2015  * preimage claim backward will lead to loss of funds.
2016  */
2017 typedef struct MUST_USE_STRUCT LDKHTLCUpdate {
2018    /**
2019     * A pointer to the opaque Rust object.
2020     * Nearly everywhere, inner must be non-null, however in places where
2021     * the Rust equivalent takes an Option, it may be set to null to indicate None.
2022     */
2023    LDKnativeHTLCUpdate *inner;
2024    /**
2025     * Indicates that this is the only struct which contains the same pointer.
2026     * Rust functions which take ownership of an object provided via an argument require
2027     * this to be true and invalidate the object pointed to by inner.
2028     */
2029    bool is_owned;
2030 } LDKHTLCUpdate;
2031
2032
2033
2034 /**
2035  * A reference to a transaction output.
2036  *
2037  * Differs from bitcoin::blockdata::transaction::OutPoint as the index is a u16 instead of u32
2038  * due to LN's restrictions on index values. Should reduce (possibly) unsafe conversions this way.
2039  */
2040 typedef struct MUST_USE_STRUCT LDKOutPoint {
2041    /**
2042     * A pointer to the opaque Rust object.
2043     * Nearly everywhere, inner must be non-null, however in places where
2044     * the Rust equivalent takes an Option, it may be set to null to indicate None.
2045     */
2046    LDKnativeOutPoint *inner;
2047    /**
2048     * Indicates that this is the only struct which contains the same pointer.
2049     * Rust functions which take ownership of an object provided via an argument require
2050     * this to be true and invalidate the object pointed to by inner.
2051     */
2052    bool is_owned;
2053 } LDKOutPoint;
2054
2055 /**
2056  * An event to be processed by the ChannelManager.
2057  */
2058 typedef enum LDKMonitorEvent_Tag {
2059    /**
2060     * A monitor event containing an HTLCUpdate.
2061     */
2062    LDKMonitorEvent_HTLCEvent,
2063    /**
2064     * A monitor event that the Channel's commitment transaction was broadcasted.
2065     */
2066    LDKMonitorEvent_CommitmentTxBroadcasted,
2067    /**
2068     * Must be last for serialization purposes
2069     */
2070    LDKMonitorEvent_Sentinel,
2071 } LDKMonitorEvent_Tag;
2072
2073 typedef struct MUST_USE_STRUCT LDKMonitorEvent {
2074    LDKMonitorEvent_Tag tag;
2075    union {
2076       struct {
2077          struct LDKHTLCUpdate htlc_event;
2078       };
2079       struct {
2080          struct LDKOutPoint commitment_tx_broadcasted;
2081       };
2082    };
2083 } LDKMonitorEvent;
2084
2085 typedef struct LDKCVec_MonitorEventZ {
2086    struct LDKMonitorEvent *data;
2087    uintptr_t datalen;
2088 } LDKCVec_MonitorEventZ;
2089
2090
2091
2092 /**
2093  * Information about a spendable output to a P2WSH script. See
2094  * SpendableOutputDescriptor::DelayedPaymentOutput for more details on how to spend this.
2095  */
2096 typedef struct MUST_USE_STRUCT LDKDelayedPaymentOutputDescriptor {
2097    /**
2098     * A pointer to the opaque Rust object.
2099     * Nearly everywhere, inner must be non-null, however in places where
2100     * the Rust equivalent takes an Option, it may be set to null to indicate None.
2101     */
2102    LDKnativeDelayedPaymentOutputDescriptor *inner;
2103    /**
2104     * Indicates that this is the only struct which contains the same pointer.
2105     * Rust functions which take ownership of an object provided via an argument require
2106     * this to be true and invalidate the object pointed to by inner.
2107     */
2108    bool is_owned;
2109 } LDKDelayedPaymentOutputDescriptor;
2110
2111
2112
2113 /**
2114  * Information about a spendable output to our \"payment key\". See
2115  * SpendableOutputDescriptor::StaticPaymentOutput for more details on how to spend this.
2116  */
2117 typedef struct MUST_USE_STRUCT LDKStaticPaymentOutputDescriptor {
2118    /**
2119     * A pointer to the opaque Rust object.
2120     * Nearly everywhere, inner must be non-null, however in places where
2121     * the Rust equivalent takes an Option, it may be set to null to indicate None.
2122     */
2123    LDKnativeStaticPaymentOutputDescriptor *inner;
2124    /**
2125     * Indicates that this is the only struct which contains the same pointer.
2126     * Rust functions which take ownership of an object provided via an argument require
2127     * this to be true and invalidate the object pointed to by inner.
2128     */
2129    bool is_owned;
2130 } LDKStaticPaymentOutputDescriptor;
2131
2132 /**
2133  * When on-chain outputs are created by rust-lightning (which our counterparty is not able to
2134  * claim at any point in the future) an event is generated which you must track and be able to
2135  * spend on-chain. The information needed to do this is provided in this enum, including the
2136  * outpoint describing which txid and output index is available, the full output which exists at
2137  * that txid/index, and any keys or other information required to sign.
2138  */
2139 typedef enum LDKSpendableOutputDescriptor_Tag {
2140    /**
2141     * An output to a script which was provided via KeysInterface directly, either from
2142     * `get_destination_script()` or `get_shutdown_pubkey()`, thus you should already know how to
2143     * spend it. No secret keys are provided as rust-lightning was never given any key.
2144     * These may include outputs from a transaction punishing our counterparty or claiming an HTLC
2145     * on-chain using the payment preimage or after it has timed out.
2146     */
2147    LDKSpendableOutputDescriptor_StaticOutput,
2148    /**
2149     * An output to a P2WSH script which can be spent with a single signature after a CSV delay.
2150     *
2151     * The witness in the spending input should be:
2152     * <BIP 143 signature> <empty vector> (MINIMALIF standard rule) <provided witnessScript>
2153     *
2154     * Note that the nSequence field in the spending input must be set to to_self_delay
2155     * (which means the transaction is not broadcastable until at least to_self_delay
2156     * blocks after the outpoint confirms).
2157     *
2158     * These are generally the result of a \"revocable\" output to us, spendable only by us unless
2159     * it is an output from an old state which we broadcast (which should never happen).
2160     *
2161     * To derive the delayed_payment key which is used to sign for this input, you must pass the
2162     * holder delayed_payment_base_key (ie the private key which corresponds to the pubkey in
2163     * Sign::pubkeys().delayed_payment_basepoint) and the provided per_commitment_point to
2164     * chan_utils::derive_private_key. The public key can be generated without the secret key
2165     * using chan_utils::derive_public_key and only the delayed_payment_basepoint which appears in
2166     * Sign::pubkeys().
2167     *
2168     * To derive the revocation_pubkey provided here (which is used in the witness
2169     * script generation), you must pass the counterparty revocation_basepoint (which appears in the
2170     * call to Sign::ready_channel) and the provided per_commitment point
2171     * to chan_utils::derive_public_revocation_key.
2172     *
2173     * The witness script which is hashed and included in the output script_pubkey may be
2174     * regenerated by passing the revocation_pubkey (derived as above), our delayed_payment pubkey
2175     * (derived as above), and the to_self_delay contained here to
2176     * chan_utils::get_revokeable_redeemscript.
2177     */
2178    LDKSpendableOutputDescriptor_DelayedPaymentOutput,
2179    /**
2180     * An output to a P2WPKH, spendable exclusively by our payment key (ie the private key which
2181     * corresponds to the public key in Sign::pubkeys().payment_point).
2182     * The witness in the spending input, is, thus, simply:
2183     * <BIP 143 signature> <payment key>
2184     *
2185     * These are generally the result of our counterparty having broadcast the current state,
2186     * allowing us to claim the non-HTLC-encumbered outputs immediately.
2187     */
2188    LDKSpendableOutputDescriptor_StaticPaymentOutput,
2189    /**
2190     * Must be last for serialization purposes
2191     */
2192    LDKSpendableOutputDescriptor_Sentinel,
2193 } LDKSpendableOutputDescriptor_Tag;
2194
2195 typedef struct LDKSpendableOutputDescriptor_LDKStaticOutput_Body {
2196    /**
2197     * The outpoint which is spendable
2198     */
2199    struct LDKOutPoint outpoint;
2200    /**
2201     * The output which is referenced by the given outpoint.
2202     */
2203    struct LDKTxOut output;
2204 } LDKSpendableOutputDescriptor_LDKStaticOutput_Body;
2205
2206 typedef struct MUST_USE_STRUCT LDKSpendableOutputDescriptor {
2207    LDKSpendableOutputDescriptor_Tag tag;
2208    union {
2209       LDKSpendableOutputDescriptor_LDKStaticOutput_Body static_output;
2210       struct {
2211          struct LDKDelayedPaymentOutputDescriptor delayed_payment_output;
2212       };
2213       struct {
2214          struct LDKStaticPaymentOutputDescriptor static_payment_output;
2215       };
2216    };
2217 } LDKSpendableOutputDescriptor;
2218
2219 typedef struct LDKCVec_SpendableOutputDescriptorZ {
2220    struct LDKSpendableOutputDescriptor *data;
2221    uintptr_t datalen;
2222 } LDKCVec_SpendableOutputDescriptorZ;
2223
2224 /**
2225  * An Event which you should probably take some action in response to.
2226  *
2227  * Note that while Writeable and Readable are implemented for Event, you probably shouldn't use
2228  * them directly as they don't round-trip exactly (for example FundingGenerationReady is never
2229  * written as it makes no sense to respond to it after reconnecting to peers).
2230  */
2231 typedef enum LDKEvent_Tag {
2232    /**
2233     * Used to indicate that the client should generate a funding transaction with the given
2234     * parameters and then call ChannelManager::funding_transaction_generated.
2235     * Generated in ChannelManager message handling.
2236     * Note that *all inputs* in the funding transaction must spend SegWit outputs or your
2237     * counterparty can steal your funds!
2238     */
2239    LDKEvent_FundingGenerationReady,
2240    /**
2241     * Used to indicate that the client may now broadcast the funding transaction it created for a
2242     * channel. Broadcasting such a transaction prior to this event may lead to our counterparty
2243     * trivially stealing all funds in the funding transaction!
2244     */
2245    LDKEvent_FundingBroadcastSafe,
2246    /**
2247     * Indicates we've received money! Just gotta dig out that payment preimage and feed it to
2248     * ChannelManager::claim_funds to get it....
2249     * Note that if the preimage is not known or the amount paid is incorrect, you should call
2250     * ChannelManager::fail_htlc_backwards to free up resources for this HTLC and avoid
2251     * network congestion.
2252     * The amount paid should be considered 'incorrect' when it is less than or more than twice
2253     * the amount expected.
2254     * If you fail to call either ChannelManager::claim_funds or
2255     * ChannelManager::fail_htlc_backwards within the HTLC's timeout, the HTLC will be
2256     * automatically failed.
2257     */
2258    LDKEvent_PaymentReceived,
2259    /**
2260     * Indicates an outbound payment we made succeeded (ie it made it all the way to its target
2261     * and we got back the payment preimage for it).
2262     * Note that duplicative PaymentSent Events may be generated - it is your responsibility to
2263     * deduplicate them by payment_preimage (which MUST be unique)!
2264     */
2265    LDKEvent_PaymentSent,
2266    /**
2267     * Indicates an outbound payment we made failed. Probably some intermediary node dropped
2268     * something. You may wish to retry with a different route.
2269     * Note that duplicative PaymentFailed Events may be generated - it is your responsibility to
2270     * deduplicate them by payment_hash (which MUST be unique)!
2271     */
2272    LDKEvent_PaymentFailed,
2273    /**
2274     * Used to indicate that ChannelManager::process_pending_htlc_forwards should be called at a
2275     * time in the future.
2276     */
2277    LDKEvent_PendingHTLCsForwardable,
2278    /**
2279     * Used to indicate that an output was generated on-chain which you should know how to spend.
2280     * Such an output will *not* ever be spent by rust-lightning, and are not at risk of your
2281     * counterparty spending them due to some kind of timeout. Thus, you need to store them
2282     * somewhere and spend them when you create on-chain transactions.
2283     */
2284    LDKEvent_SpendableOutputs,
2285    /**
2286     * Must be last for serialization purposes
2287     */
2288    LDKEvent_Sentinel,
2289 } LDKEvent_Tag;
2290
2291 typedef struct LDKEvent_LDKFundingGenerationReady_Body {
2292    /**
2293     * The random channel_id we picked which you'll need to pass into
2294     * ChannelManager::funding_transaction_generated.
2295     */
2296    struct LDKThirtyTwoBytes temporary_channel_id;
2297    /**
2298     * The value, in satoshis, that the output should have.
2299     */
2300    uint64_t channel_value_satoshis;
2301    /**
2302     * The script which should be used in the transaction output.
2303     */
2304    struct LDKCVec_u8Z output_script;
2305    /**
2306     * The value passed in to ChannelManager::create_channel
2307     */
2308    uint64_t user_channel_id;
2309 } LDKEvent_LDKFundingGenerationReady_Body;
2310
2311 typedef struct LDKEvent_LDKFundingBroadcastSafe_Body {
2312    /**
2313     * The output, which was passed to ChannelManager::funding_transaction_generated, which is
2314     * now safe to broadcast.
2315     */
2316    struct LDKOutPoint funding_txo;
2317    /**
2318     * The value passed in to ChannelManager::create_channel
2319     */
2320    uint64_t user_channel_id;
2321 } LDKEvent_LDKFundingBroadcastSafe_Body;
2322
2323 typedef struct LDKEvent_LDKPaymentReceived_Body {
2324    /**
2325     * The hash for which the preimage should be handed to the ChannelManager.
2326     */
2327    struct LDKThirtyTwoBytes payment_hash;
2328    /**
2329     * The \"payment secret\". This authenticates the sender to the recipient, preventing a
2330     * number of deanonymization attacks during the routing process.
2331     * As nodes upgrade, the invoices you provide should likely migrate to setting the
2332     * payment_secret feature to required, at which point you should fail_backwards any HTLCs
2333     * which have a None here.
2334     * Until then, however, values of None should be ignored, and only incorrect Some values
2335     * should result in an HTLC fail_backwards.
2336     * Note that, in any case, this value must be passed as-is to any fail or claim calls as
2337     * the HTLC index includes this value.
2338     */
2339    struct LDKThirtyTwoBytes payment_secret;
2340    /**
2341     * The value, in thousandths of a satoshi, that this payment is for. Note that you must
2342     * compare this to the expected value before accepting the payment (as otherwise you are
2343     * providing proof-of-payment for less than the value you expected!).
2344     */
2345    uint64_t amt;
2346 } LDKEvent_LDKPaymentReceived_Body;
2347
2348 typedef struct LDKEvent_LDKPaymentSent_Body {
2349    /**
2350     * The preimage to the hash given to ChannelManager::send_payment.
2351     * Note that this serves as a payment receipt, if you wish to have such a thing, you must
2352     * store it somehow!
2353     */
2354    struct LDKThirtyTwoBytes payment_preimage;
2355 } LDKEvent_LDKPaymentSent_Body;
2356
2357 typedef struct LDKEvent_LDKPaymentFailed_Body {
2358    /**
2359     * The hash which was given to ChannelManager::send_payment.
2360     */
2361    struct LDKThirtyTwoBytes payment_hash;
2362    /**
2363     * Indicates the payment was rejected for some reason by the recipient. This implies that
2364     * the payment has failed, not just the route in question. If this is not set, you may
2365     * retry the payment via a different route.
2366     */
2367    bool rejected_by_dest;
2368 } LDKEvent_LDKPaymentFailed_Body;
2369
2370 typedef struct LDKEvent_LDKPendingHTLCsForwardable_Body {
2371    /**
2372     * The minimum amount of time that should be waited prior to calling
2373     * process_pending_htlc_forwards. To increase the effort required to correlate payments,
2374     * you should wait a random amount of time in roughly the range (now + time_forwardable,
2375     * now + 5*time_forwardable).
2376     */
2377    uint64_t time_forwardable;
2378 } LDKEvent_LDKPendingHTLCsForwardable_Body;
2379
2380 typedef struct LDKEvent_LDKSpendableOutputs_Body {
2381    /**
2382     * The outputs which you should store as spendable by you.
2383     */
2384    struct LDKCVec_SpendableOutputDescriptorZ outputs;
2385 } LDKEvent_LDKSpendableOutputs_Body;
2386
2387 typedef struct MUST_USE_STRUCT LDKEvent {
2388    LDKEvent_Tag tag;
2389    union {
2390       LDKEvent_LDKFundingGenerationReady_Body funding_generation_ready;
2391       LDKEvent_LDKFundingBroadcastSafe_Body funding_broadcast_safe;
2392       LDKEvent_LDKPaymentReceived_Body payment_received;
2393       LDKEvent_LDKPaymentSent_Body payment_sent;
2394       LDKEvent_LDKPaymentFailed_Body payment_failed;
2395       LDKEvent_LDKPendingHTLCsForwardable_Body pending_htl_cs_forwardable;
2396       LDKEvent_LDKSpendableOutputs_Body spendable_outputs;
2397    };
2398 } LDKEvent;
2399
2400 typedef struct LDKCVec_EventZ {
2401    struct LDKEvent *data;
2402    uintptr_t datalen;
2403 } LDKCVec_EventZ;
2404
2405 typedef union LDKCResult_OutPointDecodeErrorZPtr {
2406    struct LDKOutPoint *result;
2407    struct LDKDecodeError *err;
2408 } LDKCResult_OutPointDecodeErrorZPtr;
2409
2410 typedef struct LDKCResult_OutPointDecodeErrorZ {
2411    union LDKCResult_OutPointDecodeErrorZPtr contents;
2412    bool result_ok;
2413 } LDKCResult_OutPointDecodeErrorZ;
2414
2415
2416
2417 /**
2418  * An update generated by the underlying Channel itself which contains some new information the
2419  * ChannelMonitor should be made aware of.
2420  */
2421 typedef struct MUST_USE_STRUCT LDKChannelMonitorUpdate {
2422    /**
2423     * A pointer to the opaque Rust object.
2424     * Nearly everywhere, inner must be non-null, however in places where
2425     * the Rust equivalent takes an Option, it may be set to null to indicate None.
2426     */
2427    LDKnativeChannelMonitorUpdate *inner;
2428    /**
2429     * Indicates that this is the only struct which contains the same pointer.
2430     * Rust functions which take ownership of an object provided via an argument require
2431     * this to be true and invalidate the object pointed to by inner.
2432     */
2433    bool is_owned;
2434 } LDKChannelMonitorUpdate;
2435
2436 typedef union LDKCResult_ChannelMonitorUpdateDecodeErrorZPtr {
2437    struct LDKChannelMonitorUpdate *result;
2438    struct LDKDecodeError *err;
2439 } LDKCResult_ChannelMonitorUpdateDecodeErrorZPtr;
2440
2441 typedef struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ {
2442    union LDKCResult_ChannelMonitorUpdateDecodeErrorZPtr contents;
2443    bool result_ok;
2444 } LDKCResult_ChannelMonitorUpdateDecodeErrorZ;
2445
2446 typedef union LDKCResult_HTLCUpdateDecodeErrorZPtr {
2447    struct LDKHTLCUpdate *result;
2448    struct LDKDecodeError *err;
2449 } LDKCResult_HTLCUpdateDecodeErrorZPtr;
2450
2451 typedef struct LDKCResult_HTLCUpdateDecodeErrorZ {
2452    union LDKCResult_HTLCUpdateDecodeErrorZPtr contents;
2453    bool result_ok;
2454 } LDKCResult_HTLCUpdateDecodeErrorZ;
2455
2456
2457
2458 /**
2459  * General Err type for ChannelMonitor actions. Generally, this implies that the data provided is
2460  * inconsistent with the ChannelMonitor being called. eg for ChannelMonitor::update_monitor this
2461  * means you tried to update a monitor for a different channel or the ChannelMonitorUpdate was
2462  * corrupted.
2463  * Contains a developer-readable error message.
2464  */
2465 typedef struct MUST_USE_STRUCT LDKMonitorUpdateError {
2466    /**
2467     * A pointer to the opaque Rust object.
2468     * Nearly everywhere, inner must be non-null, however in places where
2469     * the Rust equivalent takes an Option, it may be set to null to indicate None.
2470     */
2471    LDKnativeMonitorUpdateError *inner;
2472    /**
2473     * Indicates that this is the only struct which contains the same pointer.
2474     * Rust functions which take ownership of an object provided via an argument require
2475     * this to be true and invalidate the object pointed to by inner.
2476     */
2477    bool is_owned;
2478 } LDKMonitorUpdateError;
2479
2480 typedef union LDKCResult_NoneMonitorUpdateErrorZPtr {
2481    /**
2482     * Note that this value is always NULL, as there are no contents in the OK variant
2483     */
2484    void *result;
2485    struct LDKMonitorUpdateError *err;
2486 } LDKCResult_NoneMonitorUpdateErrorZPtr;
2487
2488 typedef struct LDKCResult_NoneMonitorUpdateErrorZ {
2489    union LDKCResult_NoneMonitorUpdateErrorZPtr contents;
2490    bool result_ok;
2491 } LDKCResult_NoneMonitorUpdateErrorZ;
2492
2493 typedef struct LDKC2Tuple_OutPointScriptZ {
2494    struct LDKOutPoint a;
2495    struct LDKCVec_u8Z b;
2496 } LDKC2Tuple_OutPointScriptZ;
2497
2498 typedef struct LDKC2Tuple_u32ScriptZ {
2499    uint32_t a;
2500    struct LDKCVec_u8Z b;
2501 } LDKC2Tuple_u32ScriptZ;
2502
2503 typedef struct LDKCVec_C2Tuple_u32ScriptZZ {
2504    struct LDKC2Tuple_u32ScriptZ *data;
2505    uintptr_t datalen;
2506 } LDKCVec_C2Tuple_u32ScriptZZ;
2507
2508 typedef struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ {
2509    struct LDKThirtyTwoBytes a;
2510    struct LDKCVec_C2Tuple_u32ScriptZZ b;
2511 } LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ;
2512
2513 typedef struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ {
2514    struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *data;
2515    uintptr_t datalen;
2516 } LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ;
2517
2518 typedef struct LDKCVec_TransactionZ {
2519    struct LDKTransaction *data;
2520    uintptr_t datalen;
2521 } LDKCVec_TransactionZ;
2522
2523 typedef struct LDKC2Tuple_u32TxOutZ {
2524    uint32_t a;
2525    struct LDKTxOut b;
2526 } LDKC2Tuple_u32TxOutZ;
2527
2528 typedef struct LDKCVec_C2Tuple_u32TxOutZZ {
2529    struct LDKC2Tuple_u32TxOutZ *data;
2530    uintptr_t datalen;
2531 } LDKCVec_C2Tuple_u32TxOutZZ;
2532
2533 typedef struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ {
2534    struct LDKThirtyTwoBytes a;
2535    struct LDKCVec_C2Tuple_u32TxOutZZ b;
2536 } LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ;
2537
2538 typedef struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ {
2539    struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *data;
2540    uintptr_t datalen;
2541 } LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ;
2542
2543 typedef struct LDKC2Tuple_SignatureCVec_SignatureZZ {
2544    struct LDKSignature a;
2545    struct LDKCVec_SignatureZ b;
2546 } LDKC2Tuple_SignatureCVec_SignatureZZ;
2547
2548 typedef union LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZPtr {
2549    struct LDKC2Tuple_SignatureCVec_SignatureZZ *result;
2550    /**
2551     * Note that this value is always NULL, as there are no contents in the Err variant
2552     */
2553    void *err;
2554 } LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZPtr;
2555
2556 typedef struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ {
2557    union LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZPtr contents;
2558    bool result_ok;
2559 } LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ;
2560
2561 typedef union LDKCResult_SignatureNoneZPtr {
2562    struct LDKSignature *result;
2563    /**
2564     * Note that this value is always NULL, as there are no contents in the Err variant
2565     */
2566    void *err;
2567 } LDKCResult_SignatureNoneZPtr;
2568
2569 typedef struct LDKCResult_SignatureNoneZ {
2570    union LDKCResult_SignatureNoneZPtr contents;
2571    bool result_ok;
2572 } LDKCResult_SignatureNoneZ;
2573
2574
2575
2576 /**
2577  * The unsigned part of a channel_announcement
2578  */
2579 typedef struct MUST_USE_STRUCT LDKUnsignedChannelAnnouncement {
2580    /**
2581     * A pointer to the opaque Rust object.
2582     * Nearly everywhere, inner must be non-null, however in places where
2583     * the Rust equivalent takes an Option, it may be set to null to indicate None.
2584     */
2585    LDKnativeUnsignedChannelAnnouncement *inner;
2586    /**
2587     * Indicates that this is the only struct which contains the same pointer.
2588     * Rust functions which take ownership of an object provided via an argument require
2589     * this to be true and invalidate the object pointed to by inner.
2590     */
2591    bool is_owned;
2592 } LDKUnsignedChannelAnnouncement;
2593
2594 /**
2595  * A trait to sign lightning channel transactions as described in BOLT 3.
2596  *
2597  * Signing services could be implemented on a hardware wallet. In this case,
2598  * the current Sign would be a front-end on top of a communication
2599  * channel connected to your secure device and lightning key material wouldn't
2600  * reside on a hot server. Nevertheless, a this deployment would still need
2601  * to trust the ChannelManager to avoid loss of funds as this latest component
2602  * could ask to sign commitment transaction with HTLCs paying to attacker pubkeys.
2603  *
2604  * A more secure iteration would be to use hashlock (or payment points) to pair
2605  * invoice/incoming HTLCs with outgoing HTLCs to implement a no-trust-ChannelManager
2606  * at the price of more state and computation on the hardware wallet side. In the future,
2607  * we are looking forward to design such interface.
2608  *
2609  * In any case, ChannelMonitor or fallback watchtowers are always going to be trusted
2610  * to act, as liveness and breach reply correctness are always going to be hard requirements
2611  * of LN security model, orthogonal of key management issues.
2612  */
2613 typedef struct LDKSign {
2614    /**
2615     * An opaque pointer which is passed to your function implementations as an argument.
2616     * This has no meaning in the LDK, and can be NULL or any other value.
2617     */
2618    void *this_arg;
2619    /**
2620     * Gets the per-commitment point for a specific commitment number
2621     *
2622     * Note that the commitment number starts at (1 << 48) - 1 and counts backwards.
2623     */
2624    struct LDKPublicKey (*get_per_commitment_point)(const void *this_arg, uint64_t idx);
2625    /**
2626     * Gets the commitment secret for a specific commitment number as part of the revocation process
2627     *
2628     * An external signer implementation should error here if the commitment was already signed
2629     * and should refuse to sign it in the future.
2630     *
2631     * May be called more than once for the same index.
2632     *
2633     * Note that the commitment number starts at (1 << 48) - 1 and counts backwards.
2634     */
2635    struct LDKThirtyTwoBytes (*release_commitment_secret)(const void *this_arg, uint64_t idx);
2636    /**
2637     * Gets the holder's channel public keys and basepoints
2638     */
2639    struct LDKChannelPublicKeys pubkeys;
2640    /**
2641     * Fill in the pubkeys field as a reference to it will be given to Rust after this returns
2642     * Note that this takes a pointer to this object, not the this_ptr like other methods do
2643     * This function pointer may be NULL if pubkeys is filled in when this object is created and never needs updating.
2644     */
2645    void (*set_pubkeys)(const struct LDKSign*NONNULL_PTR );
2646    /**
2647     * Gets an arbitrary identifier describing the set of keys which are provided back to you in
2648     * some SpendableOutputDescriptor types. This should be sufficient to identify this
2649     * Sign object uniquely and lookup or re-derive its keys.
2650     */
2651    struct LDKThirtyTwoBytes (*channel_keys_id)(const void *this_arg);
2652    /**
2653     * Create a signature for a counterparty's commitment transaction and associated HTLC transactions.
2654     *
2655     * Note that if signing fails or is rejected, the channel will be force-closed.
2656     */
2657    struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ (*sign_counterparty_commitment)(const void *this_arg, const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx);
2658    /**
2659     * Create a signatures for a holder's commitment transaction and its claiming HTLC transactions.
2660     * This will only ever be called with a non-revoked commitment_tx.  This will be called with the
2661     * latest commitment_tx when we initiate a force-close.
2662     * This will be called with the previous latest, just to get claiming HTLC signatures, if we are
2663     * reacting to a ChannelMonitor replica that decided to broadcast before it had been updated to
2664     * the latest.
2665     * This may be called multiple times for the same transaction.
2666     *
2667     * An external signer implementation should check that the commitment has not been revoked.
2668     *
2669     * May return Err if key derivation fails.  Callers, such as ChannelMonitor, will panic in such a case.
2670     */
2671    struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ (*sign_holder_commitment_and_htlcs)(const void *this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx);
2672    /**
2673     * Create a signature for the given input in a transaction spending an HTLC or commitment
2674     * transaction output when our counterparty broadcasts an old state.
2675     *
2676     * A justice transaction may claim multiples outputs at the same time if timelocks are
2677     * similar, but only a signature for the input at index `input` should be signed for here.
2678     * It may be called multiples time for same output(s) if a fee-bump is needed with regards
2679     * to an upcoming timelock expiration.
2680     *
2681     * Amount is value of the output spent by this input, committed to in the BIP 143 signature.
2682     *
2683     * per_commitment_key is revocation secret which was provided by our counterparty when they
2684     * revoked the state which they eventually broadcast. It's not a _holder_ secret key and does
2685     * not allow the spending of any funds by itself (you need our holder revocation_secret to do
2686     * so).
2687     *
2688     * htlc holds HTLC elements (hash, timelock) if the output being spent is a HTLC output, thus
2689     * changing the format of the witness script (which is committed to in the BIP 143
2690     * signatures).
2691     */
2692    struct LDKCResult_SignatureNoneZ (*sign_justice_transaction)(const void *this_arg, struct LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (*per_commitment_key)[32], const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc);
2693    /**
2694     * Create a signature for a claiming transaction for a HTLC output on a counterparty's commitment
2695     * transaction, either offered or received.
2696     *
2697     * Such a transaction may claim multiples offered outputs at same time if we know the
2698     * preimage for each when we create it, but only the input at index `input` should be
2699     * signed for here. It may be called multiple times for same output(s) if a fee-bump is
2700     * needed with regards to an upcoming timelock expiration.
2701     *
2702     * Witness_script is either a offered or received script as defined in BOLT3 for HTLC
2703     * outputs.
2704     *
2705     * Amount is value of the output spent by this input, committed to in the BIP 143 signature.
2706     *
2707     * Per_commitment_point is the dynamic point corresponding to the channel state
2708     * detected onchain. It has been generated by our counterparty and is used to derive
2709     * channel state keys, which are then included in the witness script and committed to in the
2710     * BIP 143 signature.
2711     */
2712    struct LDKCResult_SignatureNoneZ (*sign_counterparty_htlc_transaction)(const void *this_arg, struct LDKTransaction htlc_tx, uintptr_t input, uint64_t amount, struct LDKPublicKey per_commitment_point, const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc);
2713    /**
2714     * Create a signature for a (proposed) closing transaction.
2715     *
2716     * Note that, due to rounding, there may be one \"missing\" satoshi, and either party may have
2717     * chosen to forgo their output as dust.
2718     */
2719    struct LDKCResult_SignatureNoneZ (*sign_closing_transaction)(const void *this_arg, struct LDKTransaction closing_tx);
2720    /**
2721     * Signs a channel announcement message with our funding key, proving it comes from one
2722     * of the channel participants.
2723     *
2724     * Note that if this fails or is rejected, the channel will not be publicly announced and
2725     * our counterparty may (though likely will not) close the channel on us for violating the
2726     * protocol.
2727     */
2728    struct LDKCResult_SignatureNoneZ (*sign_channel_announcement)(const void *this_arg, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg);
2729    /**
2730     * Set the counterparty static channel data, including basepoints,
2731     * counterparty_selected/holder_selected_contest_delay and funding outpoint.
2732     * This is done as soon as the funding outpoint is known.  Since these are static channel data,
2733     * they MUST NOT be allowed to change to different values once set.
2734     *
2735     * channel_parameters.is_populated() MUST be true.
2736     *
2737     * We bind holder_selected_contest_delay late here for API convenience.
2738     *
2739     * Will be called before any signatures are applied.
2740     */
2741    void (*ready_channel)(void *this_arg, const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters);
2742    /**
2743     * Creates a copy of the object pointed to by this_arg, for a copy of this Sign.
2744     * Note that the ultimate copy of the Sign will have all function pointers the same as the original.
2745     * May be NULL if no action needs to be taken, the this_arg pointer will be copied into the new Sign.
2746     */
2747    void *(*clone)(const void *this_arg);
2748    /**
2749     * Serialize the object into a byte array
2750     */
2751    struct LDKCVec_u8Z (*write)(const void *this_arg);
2752    /**
2753     * Frees any resources associated with this object given its this_arg pointer.
2754     * Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
2755     */
2756    void (*free)(void *this_arg);
2757 } LDKSign;
2758
2759
2760
2761 /**
2762  * A ChannelMonitor handles chain events (blocks connected and disconnected) and generates
2763  * on-chain transactions to ensure no loss of funds occurs.
2764  *
2765  * You MUST ensure that no ChannelMonitors for a given channel anywhere contain out-of-date
2766  * information and are actively monitoring the chain.
2767  *
2768  * Pending Events or updated HTLCs which have not yet been read out by
2769  * get_and_clear_pending_monitor_events or get_and_clear_pending_events are serialized to disk and
2770  * reloaded at deserialize-time. Thus, you must ensure that, when handling events, all events
2771  * gotten are fully handled before re-serializing the new state.
2772  *
2773  * Note that the deserializer is only implemented for (BlockHash, ChannelMonitor), which
2774  * tells you the last block hash which was block_connect()ed. You MUST rescan any blocks along
2775  * the \"reorg path\" (ie disconnecting blocks until you find a common ancestor from both the
2776  * returned block hash and the the current chain and then reconnecting blocks to get to the
2777  * best chain) upon deserializing the object!
2778  */
2779 typedef struct MUST_USE_STRUCT LDKChannelMonitor {
2780    /**
2781     * A pointer to the opaque Rust object.
2782     * Nearly everywhere, inner must be non-null, however in places where
2783     * the Rust equivalent takes an Option, it may be set to null to indicate None.
2784     */
2785    LDKnativeChannelMonitor *inner;
2786    /**
2787     * Indicates that this is the only struct which contains the same pointer.
2788     * Rust functions which take ownership of an object provided via an argument require
2789     * this to be true and invalidate the object pointed to by inner.
2790     */
2791    bool is_owned;
2792 } LDKChannelMonitor;
2793
2794 typedef struct LDKC2Tuple_BlockHashChannelMonitorZ {
2795    struct LDKThirtyTwoBytes a;
2796    struct LDKChannelMonitor b;
2797 } LDKC2Tuple_BlockHashChannelMonitorZ;
2798
2799 typedef union LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZPtr {
2800    struct LDKC2Tuple_BlockHashChannelMonitorZ *result;
2801    struct LDKDecodeError *err;
2802 } LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZPtr;
2803
2804 typedef struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ {
2805    union LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZPtr contents;
2806    bool result_ok;
2807 } LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ;
2808
2809 typedef union LDKCResult_TxOutAccessErrorZPtr {
2810    struct LDKTxOut *result;
2811    enum LDKAccessError *err;
2812 } LDKCResult_TxOutAccessErrorZPtr;
2813
2814 typedef struct LDKCResult_TxOutAccessErrorZ {
2815    union LDKCResult_TxOutAccessErrorZPtr contents;
2816    bool result_ok;
2817 } LDKCResult_TxOutAccessErrorZ;
2818
2819 /**
2820  * A Rust str object, ie a reference to a UTF8-valid string.
2821  * This is *not* null-terminated so cannot be used directly as a C string!
2822  */
2823 typedef struct LDKStr {
2824    const uint8_t *chars;
2825    uintptr_t len;
2826 } LDKStr;
2827
2828 /**
2829  * Indicates an error on the client's part (usually some variant of attempting to use too-low or
2830  * too-high values)
2831  */
2832 typedef enum LDKAPIError_Tag {
2833    /**
2834     * Indicates the API was wholly misused (see err for more). Cases where these can be returned
2835     * are documented, but generally indicates some precondition of a function was violated.
2836     */
2837    LDKAPIError_APIMisuseError,
2838    /**
2839     * Due to a high feerate, we were unable to complete the request.
2840     * For example, this may be returned if the feerate implies we cannot open a channel at the
2841     * requested value, but opening a larger channel would succeed.
2842     */
2843    LDKAPIError_FeeRateTooHigh,
2844    /**
2845     * A malformed Route was provided (eg overflowed value, node id mismatch, overly-looped route,
2846     * too-many-hops, etc).
2847     */
2848    LDKAPIError_RouteError,
2849    /**
2850     * We were unable to complete the request as the Channel required to do so is unable to
2851     * complete the request (or was not found). This can take many forms, including disconnected
2852     * peer, channel at capacity, channel shutting down, etc.
2853     */
2854    LDKAPIError_ChannelUnavailable,
2855    /**
2856     * An attempt to call watch/update_channel returned an Err (ie you did this!), causing the
2857     * attempted action to fail.
2858     */
2859    LDKAPIError_MonitorUpdateFailed,
2860    /**
2861     * Must be last for serialization purposes
2862     */
2863    LDKAPIError_Sentinel,
2864 } LDKAPIError_Tag;
2865
2866 typedef struct LDKAPIError_LDKAPIMisuseError_Body {
2867    /**
2868     * A human-readable error message
2869     */
2870    struct LDKCVec_u8Z err;
2871 } LDKAPIError_LDKAPIMisuseError_Body;
2872
2873 typedef struct LDKAPIError_LDKFeeRateTooHigh_Body {
2874    /**
2875     * A human-readable error message
2876     */
2877    struct LDKCVec_u8Z err;
2878    /**
2879     * The feerate which was too high.
2880     */
2881    uint32_t feerate;
2882 } LDKAPIError_LDKFeeRateTooHigh_Body;
2883
2884 typedef struct LDKAPIError_LDKRouteError_Body {
2885    /**
2886     * A human-readable error message
2887     */
2888    struct LDKStr err;
2889 } LDKAPIError_LDKRouteError_Body;
2890
2891 typedef struct LDKAPIError_LDKChannelUnavailable_Body {
2892    /**
2893     * A human-readable error message
2894     */
2895    struct LDKCVec_u8Z err;
2896 } LDKAPIError_LDKChannelUnavailable_Body;
2897
2898 typedef struct MUST_USE_STRUCT LDKAPIError {
2899    LDKAPIError_Tag tag;
2900    union {
2901       LDKAPIError_LDKAPIMisuseError_Body api_misuse_error;
2902       LDKAPIError_LDKFeeRateTooHigh_Body fee_rate_too_high;
2903       LDKAPIError_LDKRouteError_Body route_error;
2904       LDKAPIError_LDKChannelUnavailable_Body channel_unavailable;
2905    };
2906 } LDKAPIError;
2907
2908 typedef union LDKCResult_NoneAPIErrorZPtr {
2909    /**
2910     * Note that this value is always NULL, as there are no contents in the OK variant
2911     */
2912    void *result;
2913    struct LDKAPIError *err;
2914 } LDKCResult_NoneAPIErrorZPtr;
2915
2916 typedef struct LDKCResult_NoneAPIErrorZ {
2917    union LDKCResult_NoneAPIErrorZPtr contents;
2918    bool result_ok;
2919 } LDKCResult_NoneAPIErrorZ;
2920
2921 typedef struct LDKCVec_CResult_NoneAPIErrorZZ {
2922    struct LDKCResult_NoneAPIErrorZ *data;
2923    uintptr_t datalen;
2924 } LDKCVec_CResult_NoneAPIErrorZZ;
2925
2926 typedef struct LDKCVec_APIErrorZ {
2927    struct LDKAPIError *data;
2928    uintptr_t datalen;
2929 } LDKCVec_APIErrorZ;
2930
2931
2932
2933 /**
2934  * Details of a channel, as returned by ChannelManager::list_channels and ChannelManager::list_usable_channels
2935  */
2936 typedef struct MUST_USE_STRUCT LDKChannelDetails {
2937    /**
2938     * A pointer to the opaque Rust object.
2939     * Nearly everywhere, inner must be non-null, however in places where
2940     * the Rust equivalent takes an Option, it may be set to null to indicate None.
2941     */
2942    LDKnativeChannelDetails *inner;
2943    /**
2944     * Indicates that this is the only struct which contains the same pointer.
2945     * Rust functions which take ownership of an object provided via an argument require
2946     * this to be true and invalidate the object pointed to by inner.
2947     */
2948    bool is_owned;
2949 } LDKChannelDetails;
2950
2951 typedef struct LDKCVec_ChannelDetailsZ {
2952    struct LDKChannelDetails *data;
2953    uintptr_t datalen;
2954 } LDKCVec_ChannelDetailsZ;
2955
2956 /**
2957  * If a payment fails to send, it can be in one of several states. This enum is returned as the
2958  * Err() type describing which state the payment is in, see the description of individual enum
2959  * states for more.
2960  */
2961 typedef enum LDKPaymentSendFailure_Tag {
2962    /**
2963     * A parameter which was passed to send_payment was invalid, preventing us from attempting to
2964     * send the payment at all. No channel state has been changed or messages sent to peers, and
2965     * once you've changed the parameter at error, you can freely retry the payment in full.
2966     */
2967    LDKPaymentSendFailure_ParameterError,
2968    /**
2969     * A parameter in a single path which was passed to send_payment was invalid, preventing us
2970     * from attempting to send the payment at all. No channel state has been changed or messages
2971     * sent to peers, and once you've changed the parameter at error, you can freely retry the
2972     * payment in full.
2973     *
2974     * The results here are ordered the same as the paths in the route object which was passed to
2975     * send_payment.
2976     */
2977    LDKPaymentSendFailure_PathParameterError,
2978    /**
2979     * All paths which were attempted failed to send, with no channel state change taking place.
2980     * You can freely retry the payment in full (though you probably want to do so over different
2981     * paths than the ones selected).
2982     */
2983    LDKPaymentSendFailure_AllFailedRetrySafe,
2984    /**
2985     * Some paths which were attempted failed to send, though possibly not all. At least some
2986     * paths have irrevocably committed to the HTLC and retrying the payment in full would result
2987     * in over-/re-payment.
2988     *
2989     * The results here are ordered the same as the paths in the route object which was passed to
2990     * send_payment, and any Errs which are not APIError::MonitorUpdateFailed can be safely
2991     * retried (though there is currently no API with which to do so).
2992     *
2993     * Any entries which contain Err(APIError::MonitorUpdateFailed) or Ok(()) MUST NOT be retried
2994     * as they will result in over-/re-payment. These HTLCs all either successfully sent (in the
2995     * case of Ok(())) or will send once channel_monitor_updated is called on the next-hop channel
2996     * with the latest update_id.
2997     */
2998    LDKPaymentSendFailure_PartialFailure,
2999    /**
3000     * Must be last for serialization purposes
3001     */
3002    LDKPaymentSendFailure_Sentinel,
3003 } LDKPaymentSendFailure_Tag;
3004
3005 typedef struct MUST_USE_STRUCT LDKPaymentSendFailure {
3006    LDKPaymentSendFailure_Tag tag;
3007    union {
3008       struct {
3009          struct LDKAPIError parameter_error;
3010       };
3011       struct {
3012          struct LDKCVec_CResult_NoneAPIErrorZZ path_parameter_error;
3013       };
3014       struct {
3015          struct LDKCVec_APIErrorZ all_failed_retry_safe;
3016       };
3017       struct {
3018          struct LDKCVec_CResult_NoneAPIErrorZZ partial_failure;
3019       };
3020    };
3021 } LDKPaymentSendFailure;
3022
3023 typedef union LDKCResult_NonePaymentSendFailureZPtr {
3024    /**
3025     * Note that this value is always NULL, as there are no contents in the OK variant
3026     */
3027    void *result;
3028    struct LDKPaymentSendFailure *err;
3029 } LDKCResult_NonePaymentSendFailureZPtr;
3030
3031 typedef struct LDKCResult_NonePaymentSendFailureZ {
3032    union LDKCResult_NonePaymentSendFailureZPtr contents;
3033    bool result_ok;
3034 } LDKCResult_NonePaymentSendFailureZ;
3035
3036 typedef struct LDKCVec_ChannelMonitorZ {
3037    struct LDKChannelMonitor *data;
3038    uintptr_t datalen;
3039 } LDKCVec_ChannelMonitorZ;
3040
3041 /**
3042  * The `Watch` trait defines behavior for watching on-chain activity pertaining to channels as
3043  * blocks are connected and disconnected.
3044  *
3045  * Each channel is associated with a [`ChannelMonitor`]. Implementations of this trait are
3046  * responsible for maintaining a set of monitors such that they can be updated accordingly as
3047  * channel state changes and HTLCs are resolved. See method documentation for specific
3048  * requirements.
3049  *
3050  * Implementations **must** ensure that updates are successfully applied and persisted upon method
3051  * completion. If an update fails with a [`PermanentFailure`], then it must immediately shut down
3052  * without taking any further action such as persisting the current state.
3053  *
3054  * If an implementation maintains multiple instances of a channel's monitor (e.g., by storing
3055  * backup copies), then it must ensure that updates are applied across all instances. Otherwise, it
3056  * could result in a revoked transaction being broadcast, allowing the counterparty to claim all
3057  * funds in the channel. See [`ChannelMonitorUpdateErr`] for more details about how to handle
3058  * multiple instances.
3059  *
3060  * [`ChannelMonitor`]: channelmonitor::ChannelMonitor
3061  * [`ChannelMonitorUpdateErr`]: channelmonitor::ChannelMonitorUpdateErr
3062  * [`PermanentFailure`]: channelmonitor::ChannelMonitorUpdateErr::PermanentFailure
3063  */
3064 typedef struct LDKWatch {
3065    /**
3066     * An opaque pointer which is passed to your function implementations as an argument.
3067     * This has no meaning in the LDK, and can be NULL or any other value.
3068     */
3069    void *this_arg;
3070    /**
3071     * Watches a channel identified by `funding_txo` using `monitor`.
3072     *
3073     * Implementations are responsible for watching the chain for the funding transaction along
3074     * with any spends of outputs returned by [`get_outputs_to_watch`]. In practice, this means
3075     * calling [`block_connected`] and [`block_disconnected`] on the monitor.
3076     *
3077     * [`get_outputs_to_watch`]: channelmonitor::ChannelMonitor::get_outputs_to_watch
3078     * [`block_connected`]: channelmonitor::ChannelMonitor::block_connected
3079     * [`block_disconnected`]: channelmonitor::ChannelMonitor::block_disconnected
3080     */
3081    struct LDKCResult_NoneChannelMonitorUpdateErrZ (*watch_channel)(const void *this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor);
3082    /**
3083     * Updates a channel identified by `funding_txo` by applying `update` to its monitor.
3084     *
3085     * Implementations must call [`update_monitor`] with the given update. See
3086     * [`ChannelMonitorUpdateErr`] for invariants around returning an error.
3087     *
3088     * [`update_monitor`]: channelmonitor::ChannelMonitor::update_monitor
3089     * [`ChannelMonitorUpdateErr`]: channelmonitor::ChannelMonitorUpdateErr
3090     */
3091    struct LDKCResult_NoneChannelMonitorUpdateErrZ (*update_channel)(const void *this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitorUpdate update);
3092    /**
3093     * Returns any monitor events since the last call. Subsequent calls must only return new
3094     * events.
3095     */
3096    struct LDKCVec_MonitorEventZ (*release_pending_monitor_events)(const void *this_arg);
3097    /**
3098     * Frees any resources associated with this object given its this_arg pointer.
3099     * Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
3100     */
3101    void (*free)(void *this_arg);
3102 } LDKWatch;
3103
3104 /**
3105  * An interface to send a transaction to the Bitcoin network.
3106  */
3107 typedef struct LDKBroadcasterInterface {
3108    /**
3109     * An opaque pointer which is passed to your function implementations as an argument.
3110     * This has no meaning in the LDK, and can be NULL or any other value.
3111     */
3112    void *this_arg;
3113    /**
3114     * Sends a transaction out to (hopefully) be mined.
3115     */
3116    void (*broadcast_transaction)(const void *this_arg, struct LDKTransaction tx);
3117    /**
3118     * Frees any resources associated with this object given its this_arg pointer.
3119     * Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
3120     */
3121    void (*free)(void *this_arg);
3122 } LDKBroadcasterInterface;
3123
3124 typedef union LDKCResult_SignDecodeErrorZPtr {
3125    struct LDKSign *result;
3126    struct LDKDecodeError *err;
3127 } LDKCResult_SignDecodeErrorZPtr;
3128
3129 typedef struct LDKCResult_SignDecodeErrorZ {
3130    union LDKCResult_SignDecodeErrorZPtr contents;
3131    bool result_ok;
3132 } LDKCResult_SignDecodeErrorZ;
3133
3134 typedef struct LDKu8slice {
3135    const uint8_t *data;
3136    uintptr_t datalen;
3137 } LDKu8slice;
3138
3139 /**
3140  * A trait to describe an object which can get user secrets and key material.
3141  */
3142 typedef struct LDKKeysInterface {
3143    /**
3144     * An opaque pointer which is passed to your function implementations as an argument.
3145     * This has no meaning in the LDK, and can be NULL or any other value.
3146     */
3147    void *this_arg;
3148    /**
3149     * Get node secret key (aka node_id or network_key).
3150     *
3151     * This method must return the same value each time it is called.
3152     */
3153    struct LDKSecretKey (*get_node_secret)(const void *this_arg);
3154    /**
3155     * Get a script pubkey which we send funds to when claiming on-chain contestable outputs.
3156     *
3157     * This method should return a different value each time it is called, to avoid linking
3158     * on-chain funds across channels as controlled to the same user.
3159     */
3160    struct LDKCVec_u8Z (*get_destination_script)(const void *this_arg);
3161    /**
3162     * Get a public key which we will send funds to (in the form of a P2WPKH output) when closing
3163     * a channel.
3164     *
3165     * This method should return a different value each time it is called, to avoid linking
3166     * on-chain funds across channels as controlled to the same user.
3167     */
3168    struct LDKPublicKey (*get_shutdown_pubkey)(const void *this_arg);
3169    /**
3170     * Get a new set of Sign for per-channel secrets. These MUST be unique even if you
3171     * restarted with some stale data!
3172     *
3173     * This method must return a different value each time it is called.
3174     */
3175    struct LDKSign (*get_channel_signer)(const void *this_arg, bool inbound, uint64_t channel_value_satoshis);
3176    /**
3177     * Gets a unique, cryptographically-secure, random 32 byte value. This is used for encrypting
3178     * onion packets and for temporary channel IDs. There is no requirement that these be
3179     * persisted anywhere, though they must be unique across restarts.
3180     *
3181     * This method must return a different value each time it is called.
3182     */
3183    struct LDKThirtyTwoBytes (*get_secure_random_bytes)(const void *this_arg);
3184    /**
3185     * Reads a `Signer` for this `KeysInterface` from the given input stream.
3186     * This is only called during deserialization of other objects which contain
3187     * `Sign`-implementing objects (ie `ChannelMonitor`s and `ChannelManager`s).
3188     * The bytes are exactly those which `<Self::Signer as Writeable>::write()` writes, and
3189     * contain no versioning scheme. You may wish to include your own version prefix and ensure
3190     * you've read all of the provided bytes to ensure no corruption occurred.
3191     */
3192    struct LDKCResult_SignDecodeErrorZ (*read_chan_signer)(const void *this_arg, struct LDKu8slice reader);
3193    /**
3194     * Frees any resources associated with this object given its this_arg pointer.
3195     * Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
3196     */
3197    void (*free)(void *this_arg);
3198 } LDKKeysInterface;
3199
3200 /**
3201  * A trait which should be implemented to provide feerate information on a number of time
3202  * horizons.
3203  *
3204  * Note that all of the functions implemented here *must* be reentrant-safe (obviously - they're
3205  * called from inside the library in response to chain events, P2P events, or timer events).
3206  */
3207 typedef struct LDKFeeEstimator {
3208    /**
3209     * An opaque pointer which is passed to your function implementations as an argument.
3210     * This has no meaning in the LDK, and can be NULL or any other value.
3211     */
3212    void *this_arg;
3213    /**
3214     * Gets estimated satoshis of fee required per 1000 Weight-Units.
3215     *
3216     * Must be no smaller than 253 (ie 1 satoshi-per-byte rounded up to ensure later round-downs
3217     * don't put us below 1 satoshi-per-byte).
3218     *
3219     * This translates to:
3220     *  * satoshis-per-byte * 250
3221     *  * ceil(satoshis-per-kbyte / 4)
3222     */
3223    uint32_t (*get_est_sat_per_1000_weight)(const void *this_arg, enum LDKConfirmationTarget confirmation_target);
3224    /**
3225     * Frees any resources associated with this object given its this_arg pointer.
3226     * Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
3227     */
3228    void (*free)(void *this_arg);
3229 } LDKFeeEstimator;
3230
3231 /**
3232  * A trait encapsulating the operations required of a logger
3233  */
3234 typedef struct LDKLogger {
3235    /**
3236     * An opaque pointer which is passed to your function implementations as an argument.
3237     * This has no meaning in the LDK, and can be NULL or any other value.
3238     */
3239    void *this_arg;
3240    /**
3241     * Logs the `Record`
3242     */
3243    void (*log)(const void *this_arg, const char *record);
3244    /**
3245     * Frees any resources associated with this object given its this_arg pointer.
3246     * Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
3247     */
3248    void (*free)(void *this_arg);
3249 } LDKLogger;
3250
3251
3252
3253 /**
3254  * Manager which keeps track of a number of channels and sends messages to the appropriate
3255  * channel, also tracking HTLC preimages and forwarding onion packets appropriately.
3256  *
3257  * Implements ChannelMessageHandler, handling the multi-channel parts and passing things through
3258  * to individual Channels.
3259  *
3260  * Implements Writeable to write out all channel state to disk. Implies peer_disconnected() for
3261  * all peers during write/read (though does not modify this instance, only the instance being
3262  * serialized). This will result in any channels which have not yet exchanged funding_created (ie
3263  * called funding_transaction_generated for outbound channels).
3264  *
3265  * Note that you can be a bit lazier about writing out ChannelManager than you can be with
3266  * ChannelMonitors. With ChannelMonitors you MUST write each monitor update out to disk before
3267  * returning from chain::Watch::watch_/update_channel, with ChannelManagers, writing updates
3268  * happens out-of-band (and will prevent any other ChannelManager operations from occurring during
3269  * the serialization process). If the deserialized version is out-of-date compared to the
3270  * ChannelMonitors passed by reference to read(), those channels will be force-closed based on the
3271  * ChannelMonitor state and no funds will be lost (mod on-chain transaction fees).
3272  *
3273  * Note that the deserializer is only implemented for (BlockHash, ChannelManager), which
3274  * tells you the last block hash which was block_connect()ed. You MUST rescan any blocks along
3275  * the \"reorg path\" (ie call block_disconnected() until you get to a common block and then call
3276  * block_connected() to step towards your best block) upon deserialization before using the
3277  * object!
3278  *
3279  * Note that ChannelManager is responsible for tracking liveness of its channels and generating
3280  * ChannelUpdate messages informing peers that the channel is temporarily disabled. To avoid
3281  * spam due to quick disconnection/reconnection, updates are not sent until the channel has been
3282  * offline for a full minute. In order to track this, you must call
3283  * timer_chan_freshness_every_min roughly once per minute, though it doesn't have to be perfect.
3284  *
3285  * Rather than using a plain ChannelManager, it is preferable to use either a SimpleArcChannelManager
3286  * a SimpleRefChannelManager, for conciseness. See their documentation for more details, but
3287  * essentially you should default to using a SimpleRefChannelManager, and use a
3288  * SimpleArcChannelManager when you require a ChannelManager with a static lifetime, such as when
3289  * you're using lightning-net-tokio.
3290  */
3291 typedef struct MUST_USE_STRUCT LDKChannelManager {
3292    /**
3293     * A pointer to the opaque Rust object.
3294     * Nearly everywhere, inner must be non-null, however in places where
3295     * the Rust equivalent takes an Option, it may be set to null to indicate None.
3296     */
3297    LDKnativeChannelManager *inner;
3298    /**
3299     * Indicates that this is the only struct which contains the same pointer.
3300     * Rust functions which take ownership of an object provided via an argument require
3301     * this to be true and invalidate the object pointed to by inner.
3302     */
3303    bool is_owned;
3304 } LDKChannelManager;
3305
3306 typedef struct LDKC2Tuple_BlockHashChannelManagerZ {
3307    struct LDKThirtyTwoBytes a;
3308    struct LDKChannelManager b;
3309 } LDKC2Tuple_BlockHashChannelManagerZ;
3310
3311 typedef union LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZPtr {
3312    struct LDKC2Tuple_BlockHashChannelManagerZ *result;
3313    struct LDKDecodeError *err;
3314 } LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZPtr;
3315
3316 typedef struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ {
3317    union LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZPtr contents;
3318    bool result_ok;
3319 } LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ;
3320
3321 typedef union LDKCResult_SpendableOutputDescriptorDecodeErrorZPtr {
3322    struct LDKSpendableOutputDescriptor *result;
3323    struct LDKDecodeError *err;
3324 } LDKCResult_SpendableOutputDescriptorDecodeErrorZPtr;
3325
3326 typedef struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ {
3327    union LDKCResult_SpendableOutputDescriptorDecodeErrorZPtr contents;
3328    bool result_ok;
3329 } LDKCResult_SpendableOutputDescriptorDecodeErrorZ;
3330
3331 typedef struct LDKCVec_CVec_u8ZZ {
3332    struct LDKCVec_u8Z *data;
3333    uintptr_t datalen;
3334 } LDKCVec_CVec_u8ZZ;
3335
3336 typedef union LDKCResult_CVec_CVec_u8ZZNoneZPtr {
3337    struct LDKCVec_CVec_u8ZZ *result;
3338    /**
3339     * Note that this value is always NULL, as there are no contents in the Err variant
3340     */
3341    void *err;
3342 } LDKCResult_CVec_CVec_u8ZZNoneZPtr;
3343
3344 typedef struct LDKCResult_CVec_CVec_u8ZZNoneZ {
3345    union LDKCResult_CVec_CVec_u8ZZNoneZPtr contents;
3346    bool result_ok;
3347 } LDKCResult_CVec_CVec_u8ZZNoneZ;
3348
3349
3350
3351 /**
3352  * A simple implementation of Sign that just keeps the private keys in memory.
3353  *
3354  * This implementation performs no policy checks and is insufficient by itself as
3355  * a secure external signer.
3356  */
3357 typedef struct MUST_USE_STRUCT LDKInMemorySigner {
3358    /**
3359     * A pointer to the opaque Rust object.
3360     * Nearly everywhere, inner must be non-null, however in places where
3361     * the Rust equivalent takes an Option, it may be set to null to indicate None.
3362     */
3363    LDKnativeInMemorySigner *inner;
3364    /**
3365     * Indicates that this is the only struct which contains the same pointer.
3366     * Rust functions which take ownership of an object provided via an argument require
3367     * this to be true and invalidate the object pointed to by inner.
3368     */
3369    bool is_owned;
3370 } LDKInMemorySigner;
3371
3372 typedef union LDKCResult_InMemorySignerDecodeErrorZPtr {
3373    struct LDKInMemorySigner *result;
3374    struct LDKDecodeError *err;
3375 } LDKCResult_InMemorySignerDecodeErrorZPtr;
3376
3377 typedef struct LDKCResult_InMemorySignerDecodeErrorZ {
3378    union LDKCResult_InMemorySignerDecodeErrorZPtr contents;
3379    bool result_ok;
3380 } LDKCResult_InMemorySignerDecodeErrorZ;
3381
3382 typedef struct LDKCVec_TxOutZ {
3383    struct LDKTxOut *data;
3384    uintptr_t datalen;
3385 } LDKCVec_TxOutZ;
3386
3387 typedef union LDKCResult_TransactionNoneZPtr {
3388    struct LDKTransaction *result;
3389    /**
3390     * Note that this value is always NULL, as there are no contents in the Err variant
3391     */
3392    void *err;
3393 } LDKCResult_TransactionNoneZPtr;
3394
3395 typedef struct LDKCResult_TransactionNoneZ {
3396    union LDKCResult_TransactionNoneZPtr contents;
3397    bool result_ok;
3398 } LDKCResult_TransactionNoneZ;
3399
3400
3401
3402 /**
3403  * A hop in a route
3404  */
3405 typedef struct MUST_USE_STRUCT LDKRouteHop {
3406    /**
3407     * A pointer to the opaque Rust object.
3408     * Nearly everywhere, inner must be non-null, however in places where
3409     * the Rust equivalent takes an Option, it may be set to null to indicate None.
3410     */
3411    LDKnativeRouteHop *inner;
3412    /**
3413     * Indicates that this is the only struct which contains the same pointer.
3414     * Rust functions which take ownership of an object provided via an argument require
3415     * this to be true and invalidate the object pointed to by inner.
3416     */
3417    bool is_owned;
3418 } LDKRouteHop;
3419
3420 typedef struct LDKCVec_RouteHopZ {
3421    struct LDKRouteHop *data;
3422    uintptr_t datalen;
3423 } LDKCVec_RouteHopZ;
3424
3425 typedef struct LDKCVec_CVec_RouteHopZZ {
3426    struct LDKCVec_RouteHopZ *data;
3427    uintptr_t datalen;
3428 } LDKCVec_CVec_RouteHopZZ;
3429
3430
3431
3432 /**
3433  * A route directs a payment from the sender (us) to the recipient. If the recipient supports MPP,
3434  * it can take multiple paths. Each path is composed of one or more hops through the network.
3435  */
3436 typedef struct MUST_USE_STRUCT LDKRoute {
3437    /**
3438     * A pointer to the opaque Rust object.
3439     * Nearly everywhere, inner must be non-null, however in places where
3440     * the Rust equivalent takes an Option, it may be set to null to indicate None.
3441     */
3442    LDKnativeRoute *inner;
3443    /**
3444     * Indicates that this is the only struct which contains the same pointer.
3445     * Rust functions which take ownership of an object provided via an argument require
3446     * this to be true and invalidate the object pointed to by inner.
3447     */
3448    bool is_owned;
3449 } LDKRoute;
3450
3451 typedef union LDKCResult_RouteDecodeErrorZPtr {
3452    struct LDKRoute *result;
3453    struct LDKDecodeError *err;
3454 } LDKCResult_RouteDecodeErrorZPtr;
3455
3456 typedef struct LDKCResult_RouteDecodeErrorZ {
3457    union LDKCResult_RouteDecodeErrorZPtr contents;
3458    bool result_ok;
3459 } LDKCResult_RouteDecodeErrorZ;
3460
3461
3462
3463 /**
3464  * A channel descriptor which provides a last-hop route to get_route
3465  */
3466 typedef struct MUST_USE_STRUCT LDKRouteHint {
3467    /**
3468     * A pointer to the opaque Rust object.
3469     * Nearly everywhere, inner must be non-null, however in places where
3470     * the Rust equivalent takes an Option, it may be set to null to indicate None.
3471     */
3472    LDKnativeRouteHint *inner;
3473    /**
3474     * Indicates that this is the only struct which contains the same pointer.
3475     * Rust functions which take ownership of an object provided via an argument require
3476     * this to be true and invalidate the object pointed to by inner.
3477     */
3478    bool is_owned;
3479 } LDKRouteHint;
3480
3481 typedef struct LDKCVec_RouteHintZ {
3482    struct LDKRouteHint *data;
3483    uintptr_t datalen;
3484 } LDKCVec_RouteHintZ;
3485
3486 typedef union LDKCResult_RouteLightningErrorZPtr {
3487    struct LDKRoute *result;
3488    struct LDKLightningError *err;
3489 } LDKCResult_RouteLightningErrorZPtr;
3490
3491 typedef struct LDKCResult_RouteLightningErrorZ {
3492    union LDKCResult_RouteLightningErrorZPtr contents;
3493    bool result_ok;
3494 } LDKCResult_RouteLightningErrorZ;
3495
3496 typedef union LDKCResult_NetAddressu8ZPtr {
3497    struct LDKNetAddress *result;
3498    uint8_t *err;
3499 } LDKCResult_NetAddressu8ZPtr;
3500
3501 typedef struct LDKCResult_NetAddressu8Z {
3502    union LDKCResult_NetAddressu8ZPtr contents;
3503    bool result_ok;
3504 } LDKCResult_NetAddressu8Z;
3505
3506 typedef union LDKCResult_CResult_NetAddressu8ZDecodeErrorZPtr {
3507    struct LDKCResult_NetAddressu8Z *result;
3508    struct LDKDecodeError *err;
3509 } LDKCResult_CResult_NetAddressu8ZDecodeErrorZPtr;
3510
3511 typedef struct LDKCResult_CResult_NetAddressu8ZDecodeErrorZ {
3512    union LDKCResult_CResult_NetAddressu8ZDecodeErrorZPtr contents;
3513    bool result_ok;
3514 } LDKCResult_CResult_NetAddressu8ZDecodeErrorZ;
3515
3516
3517
3518 /**
3519  * An update_add_htlc message to be sent or received from a peer
3520  */
3521 typedef struct MUST_USE_STRUCT LDKUpdateAddHTLC {
3522    /**
3523     * A pointer to the opaque Rust object.
3524     * Nearly everywhere, inner must be non-null, however in places where
3525     * the Rust equivalent takes an Option, it may be set to null to indicate None.
3526     */
3527    LDKnativeUpdateAddHTLC *inner;
3528    /**
3529     * Indicates that this is the only struct which contains the same pointer.
3530     * Rust functions which take ownership of an object provided via an argument require
3531     * this to be true and invalidate the object pointed to by inner.
3532     */
3533    bool is_owned;
3534 } LDKUpdateAddHTLC;
3535
3536 typedef struct LDKCVec_UpdateAddHTLCZ {
3537    struct LDKUpdateAddHTLC *data;
3538    uintptr_t datalen;
3539 } LDKCVec_UpdateAddHTLCZ;
3540
3541
3542
3543 /**
3544  * An update_fulfill_htlc message to be sent or received from a peer
3545  */
3546 typedef struct MUST_USE_STRUCT LDKUpdateFulfillHTLC {
3547    /**
3548     * A pointer to the opaque Rust object.
3549     * Nearly everywhere, inner must be non-null, however in places where
3550     * the Rust equivalent takes an Option, it may be set to null to indicate None.
3551     */
3552    LDKnativeUpdateFulfillHTLC *inner;
3553    /**
3554     * Indicates that this is the only struct which contains the same pointer.
3555     * Rust functions which take ownership of an object provided via an argument require
3556     * this to be true and invalidate the object pointed to by inner.
3557     */
3558    bool is_owned;
3559 } LDKUpdateFulfillHTLC;
3560
3561 typedef struct LDKCVec_UpdateFulfillHTLCZ {
3562    struct LDKUpdateFulfillHTLC *data;
3563    uintptr_t datalen;
3564 } LDKCVec_UpdateFulfillHTLCZ;
3565
3566
3567
3568 /**
3569  * An update_fail_htlc message to be sent or received from a peer
3570  */
3571 typedef struct MUST_USE_STRUCT LDKUpdateFailHTLC {
3572    /**
3573     * A pointer to the opaque Rust object.
3574     * Nearly everywhere, inner must be non-null, however in places where
3575     * the Rust equivalent takes an Option, it may be set to null to indicate None.
3576     */
3577    LDKnativeUpdateFailHTLC *inner;
3578    /**
3579     * Indicates that this is the only struct which contains the same pointer.
3580     * Rust functions which take ownership of an object provided via an argument require
3581     * this to be true and invalidate the object pointed to by inner.
3582     */
3583    bool is_owned;
3584 } LDKUpdateFailHTLC;
3585
3586 typedef struct LDKCVec_UpdateFailHTLCZ {
3587    struct LDKUpdateFailHTLC *data;
3588    uintptr_t datalen;
3589 } LDKCVec_UpdateFailHTLCZ;
3590
3591
3592
3593 /**
3594  * An update_fail_malformed_htlc message to be sent or received from a peer
3595  */
3596 typedef struct MUST_USE_STRUCT LDKUpdateFailMalformedHTLC {
3597    /**
3598     * A pointer to the opaque Rust object.
3599     * Nearly everywhere, inner must be non-null, however in places where
3600     * the Rust equivalent takes an Option, it may be set to null to indicate None.
3601     */
3602    LDKnativeUpdateFailMalformedHTLC *inner;
3603    /**
3604     * Indicates that this is the only struct which contains the same pointer.
3605     * Rust functions which take ownership of an object provided via an argument require
3606     * this to be true and invalidate the object pointed to by inner.
3607     */
3608    bool is_owned;
3609 } LDKUpdateFailMalformedHTLC;
3610
3611 typedef struct LDKCVec_UpdateFailMalformedHTLCZ {
3612    struct LDKUpdateFailMalformedHTLC *data;
3613    uintptr_t datalen;
3614 } LDKCVec_UpdateFailMalformedHTLCZ;
3615
3616 typedef union LDKCResult_AcceptChannelDecodeErrorZPtr {
3617    struct LDKAcceptChannel *result;
3618    struct LDKDecodeError *err;
3619 } LDKCResult_AcceptChannelDecodeErrorZPtr;
3620
3621 typedef struct LDKCResult_AcceptChannelDecodeErrorZ {
3622    union LDKCResult_AcceptChannelDecodeErrorZPtr contents;
3623    bool result_ok;
3624 } LDKCResult_AcceptChannelDecodeErrorZ;
3625
3626 typedef union LDKCResult_AnnouncementSignaturesDecodeErrorZPtr {
3627    struct LDKAnnouncementSignatures *result;
3628    struct LDKDecodeError *err;
3629 } LDKCResult_AnnouncementSignaturesDecodeErrorZPtr;
3630
3631 typedef struct LDKCResult_AnnouncementSignaturesDecodeErrorZ {
3632    union LDKCResult_AnnouncementSignaturesDecodeErrorZPtr contents;
3633    bool result_ok;
3634 } LDKCResult_AnnouncementSignaturesDecodeErrorZ;
3635
3636 typedef union LDKCResult_ChannelReestablishDecodeErrorZPtr {
3637    struct LDKChannelReestablish *result;
3638    struct LDKDecodeError *err;
3639 } LDKCResult_ChannelReestablishDecodeErrorZPtr;
3640
3641 typedef struct LDKCResult_ChannelReestablishDecodeErrorZ {
3642    union LDKCResult_ChannelReestablishDecodeErrorZPtr contents;
3643    bool result_ok;
3644 } LDKCResult_ChannelReestablishDecodeErrorZ;
3645
3646 typedef union LDKCResult_ClosingSignedDecodeErrorZPtr {
3647    struct LDKClosingSigned *result;
3648    struct LDKDecodeError *err;
3649 } LDKCResult_ClosingSignedDecodeErrorZPtr;
3650
3651 typedef struct LDKCResult_ClosingSignedDecodeErrorZ {
3652    union LDKCResult_ClosingSignedDecodeErrorZPtr contents;
3653    bool result_ok;
3654 } LDKCResult_ClosingSignedDecodeErrorZ;
3655
3656
3657
3658 /**
3659  * A commitment_signed message to be sent or received from a peer
3660  */
3661 typedef struct MUST_USE_STRUCT LDKCommitmentSigned {
3662    /**
3663     * A pointer to the opaque Rust object.
3664     * Nearly everywhere, inner must be non-null, however in places where
3665     * the Rust equivalent takes an Option, it may be set to null to indicate None.
3666     */
3667    LDKnativeCommitmentSigned *inner;
3668    /**
3669     * Indicates that this is the only struct which contains the same pointer.
3670     * Rust functions which take ownership of an object provided via an argument require
3671     * this to be true and invalidate the object pointed to by inner.
3672     */
3673    bool is_owned;
3674 } LDKCommitmentSigned;
3675
3676 typedef union LDKCResult_CommitmentSignedDecodeErrorZPtr {
3677    struct LDKCommitmentSigned *result;
3678    struct LDKDecodeError *err;
3679 } LDKCResult_CommitmentSignedDecodeErrorZPtr;
3680
3681 typedef struct LDKCResult_CommitmentSignedDecodeErrorZ {
3682    union LDKCResult_CommitmentSignedDecodeErrorZPtr contents;
3683    bool result_ok;
3684 } LDKCResult_CommitmentSignedDecodeErrorZ;
3685
3686 typedef union LDKCResult_FundingCreatedDecodeErrorZPtr {
3687    struct LDKFundingCreated *result;
3688    struct LDKDecodeError *err;
3689 } LDKCResult_FundingCreatedDecodeErrorZPtr;
3690
3691 typedef struct LDKCResult_FundingCreatedDecodeErrorZ {
3692    union LDKCResult_FundingCreatedDecodeErrorZPtr contents;
3693    bool result_ok;
3694 } LDKCResult_FundingCreatedDecodeErrorZ;
3695
3696 typedef union LDKCResult_FundingSignedDecodeErrorZPtr {
3697    struct LDKFundingSigned *result;
3698    struct LDKDecodeError *err;
3699 } LDKCResult_FundingSignedDecodeErrorZPtr;
3700
3701 typedef struct LDKCResult_FundingSignedDecodeErrorZ {
3702    union LDKCResult_FundingSignedDecodeErrorZPtr contents;
3703    bool result_ok;
3704 } LDKCResult_FundingSignedDecodeErrorZ;
3705
3706 typedef union LDKCResult_FundingLockedDecodeErrorZPtr {
3707    struct LDKFundingLocked *result;
3708    struct LDKDecodeError *err;
3709 } LDKCResult_FundingLockedDecodeErrorZPtr;
3710
3711 typedef struct LDKCResult_FundingLockedDecodeErrorZ {
3712    union LDKCResult_FundingLockedDecodeErrorZPtr contents;
3713    bool result_ok;
3714 } LDKCResult_FundingLockedDecodeErrorZ;
3715
3716
3717
3718 /**
3719  * An init message to be sent or received from a peer
3720  */
3721 typedef struct MUST_USE_STRUCT LDKInit {
3722    /**
3723     * A pointer to the opaque Rust object.
3724     * Nearly everywhere, inner must be non-null, however in places where
3725     * the Rust equivalent takes an Option, it may be set to null to indicate None.
3726     */
3727    LDKnativeInit *inner;
3728    /**
3729     * Indicates that this is the only struct which contains the same pointer.
3730     * Rust functions which take ownership of an object provided via an argument require
3731     * this to be true and invalidate the object pointed to by inner.
3732     */
3733    bool is_owned;
3734 } LDKInit;
3735
3736 typedef union LDKCResult_InitDecodeErrorZPtr {
3737    struct LDKInit *result;
3738    struct LDKDecodeError *err;
3739 } LDKCResult_InitDecodeErrorZPtr;
3740
3741 typedef struct LDKCResult_InitDecodeErrorZ {
3742    union LDKCResult_InitDecodeErrorZPtr contents;
3743    bool result_ok;
3744 } LDKCResult_InitDecodeErrorZ;
3745
3746 typedef union LDKCResult_OpenChannelDecodeErrorZPtr {
3747    struct LDKOpenChannel *result;
3748    struct LDKDecodeError *err;
3749 } LDKCResult_OpenChannelDecodeErrorZPtr;
3750
3751 typedef struct LDKCResult_OpenChannelDecodeErrorZ {
3752    union LDKCResult_OpenChannelDecodeErrorZPtr contents;
3753    bool result_ok;
3754 } LDKCResult_OpenChannelDecodeErrorZ;
3755
3756 typedef union LDKCResult_RevokeAndACKDecodeErrorZPtr {
3757    struct LDKRevokeAndACK *result;
3758    struct LDKDecodeError *err;
3759 } LDKCResult_RevokeAndACKDecodeErrorZPtr;
3760
3761 typedef struct LDKCResult_RevokeAndACKDecodeErrorZ {
3762    union LDKCResult_RevokeAndACKDecodeErrorZPtr contents;
3763    bool result_ok;
3764 } LDKCResult_RevokeAndACKDecodeErrorZ;
3765
3766 typedef union LDKCResult_ShutdownDecodeErrorZPtr {
3767    struct LDKShutdown *result;
3768    struct LDKDecodeError *err;
3769 } LDKCResult_ShutdownDecodeErrorZPtr;
3770
3771 typedef struct LDKCResult_ShutdownDecodeErrorZ {
3772    union LDKCResult_ShutdownDecodeErrorZPtr contents;
3773    bool result_ok;
3774 } LDKCResult_ShutdownDecodeErrorZ;
3775
3776 typedef union LDKCResult_UpdateFailHTLCDecodeErrorZPtr {
3777    struct LDKUpdateFailHTLC *result;
3778    struct LDKDecodeError *err;
3779 } LDKCResult_UpdateFailHTLCDecodeErrorZPtr;
3780
3781 typedef struct LDKCResult_UpdateFailHTLCDecodeErrorZ {
3782    union LDKCResult_UpdateFailHTLCDecodeErrorZPtr contents;
3783    bool result_ok;
3784 } LDKCResult_UpdateFailHTLCDecodeErrorZ;
3785
3786 typedef union LDKCResult_UpdateFailMalformedHTLCDecodeErrorZPtr {
3787    struct LDKUpdateFailMalformedHTLC *result;
3788    struct LDKDecodeError *err;
3789 } LDKCResult_UpdateFailMalformedHTLCDecodeErrorZPtr;
3790
3791 typedef struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ {
3792    union LDKCResult_UpdateFailMalformedHTLCDecodeErrorZPtr contents;
3793    bool result_ok;
3794 } LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ;
3795
3796
3797
3798 /**
3799  * An update_fee message to be sent or received from a peer
3800  */
3801 typedef struct MUST_USE_STRUCT LDKUpdateFee {
3802    /**
3803     * A pointer to the opaque Rust object.
3804     * Nearly everywhere, inner must be non-null, however in places where
3805     * the Rust equivalent takes an Option, it may be set to null to indicate None.
3806     */
3807    LDKnativeUpdateFee *inner;
3808    /**
3809     * Indicates that this is the only struct which contains the same pointer.
3810     * Rust functions which take ownership of an object provided via an argument require
3811     * this to be true and invalidate the object pointed to by inner.
3812     */
3813    bool is_owned;
3814 } LDKUpdateFee;
3815
3816 typedef union LDKCResult_UpdateFeeDecodeErrorZPtr {
3817    struct LDKUpdateFee *result;
3818    struct LDKDecodeError *err;
3819 } LDKCResult_UpdateFeeDecodeErrorZPtr;
3820
3821 typedef struct LDKCResult_UpdateFeeDecodeErrorZ {
3822    union LDKCResult_UpdateFeeDecodeErrorZPtr contents;
3823    bool result_ok;
3824 } LDKCResult_UpdateFeeDecodeErrorZ;
3825
3826 typedef union LDKCResult_UpdateFulfillHTLCDecodeErrorZPtr {
3827    struct LDKUpdateFulfillHTLC *result;
3828    struct LDKDecodeError *err;
3829 } LDKCResult_UpdateFulfillHTLCDecodeErrorZPtr;
3830
3831 typedef struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ {
3832    union LDKCResult_UpdateFulfillHTLCDecodeErrorZPtr contents;
3833    bool result_ok;
3834 } LDKCResult_UpdateFulfillHTLCDecodeErrorZ;
3835
3836 typedef union LDKCResult_UpdateAddHTLCDecodeErrorZPtr {
3837    struct LDKUpdateAddHTLC *result;
3838    struct LDKDecodeError *err;
3839 } LDKCResult_UpdateAddHTLCDecodeErrorZPtr;
3840
3841 typedef struct LDKCResult_UpdateAddHTLCDecodeErrorZ {
3842    union LDKCResult_UpdateAddHTLCDecodeErrorZPtr contents;
3843    bool result_ok;
3844 } LDKCResult_UpdateAddHTLCDecodeErrorZ;
3845
3846
3847
3848 /**
3849  * A ping message to be sent or received from a peer
3850  */
3851 typedef struct MUST_USE_STRUCT LDKPing {
3852    /**
3853     * A pointer to the opaque Rust object.
3854     * Nearly everywhere, inner must be non-null, however in places where
3855     * the Rust equivalent takes an Option, it may be set to null to indicate None.
3856     */
3857    LDKnativePing *inner;
3858    /**
3859     * Indicates that this is the only struct which contains the same pointer.
3860     * Rust functions which take ownership of an object provided via an argument require
3861     * this to be true and invalidate the object pointed to by inner.
3862     */
3863    bool is_owned;
3864 } LDKPing;
3865
3866 typedef union LDKCResult_PingDecodeErrorZPtr {
3867    struct LDKPing *result;
3868    struct LDKDecodeError *err;
3869 } LDKCResult_PingDecodeErrorZPtr;
3870
3871 typedef struct LDKCResult_PingDecodeErrorZ {
3872    union LDKCResult_PingDecodeErrorZPtr contents;
3873    bool result_ok;
3874 } LDKCResult_PingDecodeErrorZ;
3875
3876
3877
3878 /**
3879  * A pong message to be sent or received from a peer
3880  */
3881 typedef struct MUST_USE_STRUCT LDKPong {
3882    /**
3883     * A pointer to the opaque Rust object.
3884     * Nearly everywhere, inner must be non-null, however in places where
3885     * the Rust equivalent takes an Option, it may be set to null to indicate None.
3886     */
3887    LDKnativePong *inner;
3888    /**
3889     * Indicates that this is the only struct which contains the same pointer.
3890     * Rust functions which take ownership of an object provided via an argument require
3891     * this to be true and invalidate the object pointed to by inner.
3892     */
3893    bool is_owned;
3894 } LDKPong;
3895
3896 typedef union LDKCResult_PongDecodeErrorZPtr {
3897    struct LDKPong *result;
3898    struct LDKDecodeError *err;
3899 } LDKCResult_PongDecodeErrorZPtr;
3900
3901 typedef struct LDKCResult_PongDecodeErrorZ {
3902    union LDKCResult_PongDecodeErrorZPtr contents;
3903    bool result_ok;
3904 } LDKCResult_PongDecodeErrorZ;
3905
3906 typedef union LDKCResult_UnsignedChannelAnnouncementDecodeErrorZPtr {
3907    struct LDKUnsignedChannelAnnouncement *result;
3908    struct LDKDecodeError *err;
3909 } LDKCResult_UnsignedChannelAnnouncementDecodeErrorZPtr;
3910
3911 typedef struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ {
3912    union LDKCResult_UnsignedChannelAnnouncementDecodeErrorZPtr contents;
3913    bool result_ok;
3914 } LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ;
3915
3916 typedef union LDKCResult_ChannelAnnouncementDecodeErrorZPtr {
3917    struct LDKChannelAnnouncement *result;
3918    struct LDKDecodeError *err;
3919 } LDKCResult_ChannelAnnouncementDecodeErrorZPtr;
3920
3921 typedef struct LDKCResult_ChannelAnnouncementDecodeErrorZ {
3922    union LDKCResult_ChannelAnnouncementDecodeErrorZPtr contents;
3923    bool result_ok;
3924 } LDKCResult_ChannelAnnouncementDecodeErrorZ;
3925
3926
3927
3928 /**
3929  * The unsigned part of a channel_update
3930  */
3931 typedef struct MUST_USE_STRUCT LDKUnsignedChannelUpdate {
3932    /**
3933     * A pointer to the opaque Rust object.
3934     * Nearly everywhere, inner must be non-null, however in places where
3935     * the Rust equivalent takes an Option, it may be set to null to indicate None.
3936     */
3937    LDKnativeUnsignedChannelUpdate *inner;
3938    /**
3939     * Indicates that this is the only struct which contains the same pointer.
3940     * Rust functions which take ownership of an object provided via an argument require
3941     * this to be true and invalidate the object pointed to by inner.
3942     */
3943    bool is_owned;
3944 } LDKUnsignedChannelUpdate;
3945
3946 typedef union LDKCResult_UnsignedChannelUpdateDecodeErrorZPtr {
3947    struct LDKUnsignedChannelUpdate *result;
3948    struct LDKDecodeError *err;
3949 } LDKCResult_UnsignedChannelUpdateDecodeErrorZPtr;
3950
3951 typedef struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ {
3952    union LDKCResult_UnsignedChannelUpdateDecodeErrorZPtr contents;
3953    bool result_ok;
3954 } LDKCResult_UnsignedChannelUpdateDecodeErrorZ;
3955
3956 typedef union LDKCResult_ChannelUpdateDecodeErrorZPtr {
3957    struct LDKChannelUpdate *result;
3958    struct LDKDecodeError *err;
3959 } LDKCResult_ChannelUpdateDecodeErrorZPtr;
3960
3961 typedef struct LDKCResult_ChannelUpdateDecodeErrorZ {
3962    union LDKCResult_ChannelUpdateDecodeErrorZPtr contents;
3963    bool result_ok;
3964 } LDKCResult_ChannelUpdateDecodeErrorZ;
3965
3966 typedef union LDKCResult_ErrorMessageDecodeErrorZPtr {
3967    struct LDKErrorMessage *result;
3968    struct LDKDecodeError *err;
3969 } LDKCResult_ErrorMessageDecodeErrorZPtr;
3970
3971 typedef struct LDKCResult_ErrorMessageDecodeErrorZ {
3972    union LDKCResult_ErrorMessageDecodeErrorZPtr contents;
3973    bool result_ok;
3974 } LDKCResult_ErrorMessageDecodeErrorZ;
3975
3976
3977
3978 /**
3979  * The unsigned part of a node_announcement
3980  */
3981 typedef struct MUST_USE_STRUCT LDKUnsignedNodeAnnouncement {
3982    /**
3983     * A pointer to the opaque Rust object.
3984     * Nearly everywhere, inner must be non-null, however in places where
3985     * the Rust equivalent takes an Option, it may be set to null to indicate None.
3986     */
3987    LDKnativeUnsignedNodeAnnouncement *inner;
3988    /**
3989     * Indicates that this is the only struct which contains the same pointer.
3990     * Rust functions which take ownership of an object provided via an argument require
3991     * this to be true and invalidate the object pointed to by inner.
3992     */
3993    bool is_owned;
3994 } LDKUnsignedNodeAnnouncement;
3995
3996 typedef union LDKCResult_UnsignedNodeAnnouncementDecodeErrorZPtr {
3997    struct LDKUnsignedNodeAnnouncement *result;
3998    struct LDKDecodeError *err;
3999 } LDKCResult_UnsignedNodeAnnouncementDecodeErrorZPtr;
4000
4001 typedef struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ {
4002    union LDKCResult_UnsignedNodeAnnouncementDecodeErrorZPtr contents;
4003    bool result_ok;
4004 } LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ;
4005
4006 typedef union LDKCResult_NodeAnnouncementDecodeErrorZPtr {
4007    struct LDKNodeAnnouncement *result;
4008    struct LDKDecodeError *err;
4009 } LDKCResult_NodeAnnouncementDecodeErrorZPtr;
4010
4011 typedef struct LDKCResult_NodeAnnouncementDecodeErrorZ {
4012    union LDKCResult_NodeAnnouncementDecodeErrorZPtr contents;
4013    bool result_ok;
4014 } LDKCResult_NodeAnnouncementDecodeErrorZ;
4015
4016 typedef union LDKCResult_QueryShortChannelIdsDecodeErrorZPtr {
4017    struct LDKQueryShortChannelIds *result;
4018    struct LDKDecodeError *err;
4019 } LDKCResult_QueryShortChannelIdsDecodeErrorZPtr;
4020
4021 typedef struct LDKCResult_QueryShortChannelIdsDecodeErrorZ {
4022    union LDKCResult_QueryShortChannelIdsDecodeErrorZPtr contents;
4023    bool result_ok;
4024 } LDKCResult_QueryShortChannelIdsDecodeErrorZ;
4025
4026
4027
4028 /**
4029  * A reply_short_channel_ids_end message is sent as a reply to a
4030  * query_short_channel_ids message. The query recipient makes a best
4031  * effort to respond based on their local network view which may not be
4032  * a perfect view of the network.
4033  */
4034 typedef struct MUST_USE_STRUCT LDKReplyShortChannelIdsEnd {
4035    /**
4036     * A pointer to the opaque Rust object.
4037     * Nearly everywhere, inner must be non-null, however in places where
4038     * the Rust equivalent takes an Option, it may be set to null to indicate None.
4039     */
4040    LDKnativeReplyShortChannelIdsEnd *inner;
4041    /**
4042     * Indicates that this is the only struct which contains the same pointer.
4043     * Rust functions which take ownership of an object provided via an argument require
4044     * this to be true and invalidate the object pointed to by inner.
4045     */
4046    bool is_owned;
4047 } LDKReplyShortChannelIdsEnd;
4048
4049 typedef union LDKCResult_ReplyShortChannelIdsEndDecodeErrorZPtr {
4050    struct LDKReplyShortChannelIdsEnd *result;
4051    struct LDKDecodeError *err;
4052 } LDKCResult_ReplyShortChannelIdsEndDecodeErrorZPtr;
4053
4054 typedef struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ {
4055    union LDKCResult_ReplyShortChannelIdsEndDecodeErrorZPtr contents;
4056    bool result_ok;
4057 } LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ;
4058
4059 typedef union LDKCResult_QueryChannelRangeDecodeErrorZPtr {
4060    struct LDKQueryChannelRange *result;
4061    struct LDKDecodeError *err;
4062 } LDKCResult_QueryChannelRangeDecodeErrorZPtr;
4063
4064 typedef struct LDKCResult_QueryChannelRangeDecodeErrorZ {
4065    union LDKCResult_QueryChannelRangeDecodeErrorZPtr contents;
4066    bool result_ok;
4067 } LDKCResult_QueryChannelRangeDecodeErrorZ;
4068
4069 typedef union LDKCResult_ReplyChannelRangeDecodeErrorZPtr {
4070    struct LDKReplyChannelRange *result;
4071    struct LDKDecodeError *err;
4072 } LDKCResult_ReplyChannelRangeDecodeErrorZPtr;
4073
4074 typedef struct LDKCResult_ReplyChannelRangeDecodeErrorZ {
4075    union LDKCResult_ReplyChannelRangeDecodeErrorZPtr contents;
4076    bool result_ok;
4077 } LDKCResult_ReplyChannelRangeDecodeErrorZ;
4078
4079
4080
4081 /**
4082  * A gossip_timestamp_filter message is used by a node to request
4083  * gossip relay for messages in the requested time range when the
4084  * gossip_queries feature has been negotiated.
4085  */
4086 typedef struct MUST_USE_STRUCT LDKGossipTimestampFilter {
4087    /**
4088     * A pointer to the opaque Rust object.
4089     * Nearly everywhere, inner must be non-null, however in places where
4090     * the Rust equivalent takes an Option, it may be set to null to indicate None.
4091     */
4092    LDKnativeGossipTimestampFilter *inner;
4093    /**
4094     * Indicates that this is the only struct which contains the same pointer.
4095     * Rust functions which take ownership of an object provided via an argument require
4096     * this to be true and invalidate the object pointed to by inner.
4097     */
4098    bool is_owned;
4099 } LDKGossipTimestampFilter;
4100
4101 typedef union LDKCResult_GossipTimestampFilterDecodeErrorZPtr {
4102    struct LDKGossipTimestampFilter *result;
4103    struct LDKDecodeError *err;
4104 } LDKCResult_GossipTimestampFilterDecodeErrorZPtr;
4105
4106 typedef struct LDKCResult_GossipTimestampFilterDecodeErrorZ {
4107    union LDKCResult_GossipTimestampFilterDecodeErrorZPtr contents;
4108    bool result_ok;
4109 } LDKCResult_GossipTimestampFilterDecodeErrorZ;
4110
4111 /**
4112  * A trait indicating an object may generate message send events
4113  */
4114 typedef struct LDKMessageSendEventsProvider {
4115    /**
4116     * An opaque pointer which is passed to your function implementations as an argument.
4117     * This has no meaning in the LDK, and can be NULL or any other value.
4118     */
4119    void *this_arg;
4120    /**
4121     * Gets the list of pending events which were generated by previous actions, clearing the list
4122     * in the process.
4123     */
4124    struct LDKCVec_MessageSendEventZ (*get_and_clear_pending_msg_events)(const void *this_arg);
4125    /**
4126     * Frees any resources associated with this object given its this_arg pointer.
4127     * Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
4128     */
4129    void (*free)(void *this_arg);
4130 } LDKMessageSendEventsProvider;
4131
4132 /**
4133  * A trait indicating an object may generate events
4134  */
4135 typedef struct LDKEventsProvider {
4136    /**
4137     * An opaque pointer which is passed to your function implementations as an argument.
4138     * This has no meaning in the LDK, and can be NULL or any other value.
4139     */
4140    void *this_arg;
4141    /**
4142     * Gets the list of pending events which were generated by previous actions, clearing the list
4143     * in the process.
4144     */
4145    struct LDKCVec_EventZ (*get_and_clear_pending_events)(const void *this_arg);
4146    /**
4147     * Frees any resources associated with this object given its this_arg pointer.
4148     * Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
4149     */
4150    void (*free)(void *this_arg);
4151 } LDKEventsProvider;
4152
4153
4154
4155 /**
4156  * Configuration we set when applicable.
4157  *
4158  * Default::default() provides sane defaults.
4159  */
4160 typedef struct MUST_USE_STRUCT LDKChannelHandshakeConfig {
4161    /**
4162     * A pointer to the opaque Rust object.
4163     * Nearly everywhere, inner must be non-null, however in places where
4164     * the Rust equivalent takes an Option, it may be set to null to indicate None.
4165     */
4166    LDKnativeChannelHandshakeConfig *inner;
4167    /**
4168     * Indicates that this is the only struct which contains the same pointer.
4169     * Rust functions which take ownership of an object provided via an argument require
4170     * this to be true and invalidate the object pointed to by inner.
4171     */
4172    bool is_owned;
4173 } LDKChannelHandshakeConfig;
4174
4175
4176
4177 /**
4178  * Optional channel limits which are applied during channel creation.
4179  *
4180  * These limits are only applied to our counterparty's limits, not our own.
4181  *
4182  * Use 0/<type>::max_value() as appropriate to skip checking.
4183  *
4184  * Provides sane defaults for most configurations.
4185  *
4186  * Most additional limits are disabled except those with which specify a default in individual
4187  * field documentation. Note that this may result in barely-usable channels, but since they
4188  * are applied mostly only to incoming channels that's not much of a problem.
4189  */
4190 typedef struct MUST_USE_STRUCT LDKChannelHandshakeLimits {
4191    /**
4192     * A pointer to the opaque Rust object.
4193     * Nearly everywhere, inner must be non-null, however in places where
4194     * the Rust equivalent takes an Option, it may be set to null to indicate None.
4195     */
4196    LDKnativeChannelHandshakeLimits *inner;
4197    /**
4198     * Indicates that this is the only struct which contains the same pointer.
4199     * Rust functions which take ownership of an object provided via an argument require
4200     * this to be true and invalidate the object pointed to by inner.
4201     */
4202    bool is_owned;
4203 } LDKChannelHandshakeLimits;
4204
4205
4206
4207 /**
4208  * Top-level config which holds ChannelHandshakeLimits and ChannelConfig.
4209  *
4210  * Default::default() provides sane defaults for most configurations
4211  * (but currently with 0 relay fees!)
4212  */
4213 typedef struct MUST_USE_STRUCT LDKUserConfig {
4214    /**
4215     * A pointer to the opaque Rust object.
4216     * Nearly everywhere, inner must be non-null, however in places where
4217     * the Rust equivalent takes an Option, it may be set to null to indicate None.
4218     */
4219    LDKnativeUserConfig *inner;
4220    /**
4221     * Indicates that this is the only struct which contains the same pointer.
4222     * Rust functions which take ownership of an object provided via an argument require
4223     * this to be true and invalidate the object pointed to by inner.
4224     */
4225    bool is_owned;
4226 } LDKUserConfig;
4227
4228 /**
4229  * The `Access` trait defines behavior for accessing chain data and state, such as blocks and
4230  * UTXOs.
4231  */
4232 typedef struct LDKAccess {
4233    /**
4234     * An opaque pointer which is passed to your function implementations as an argument.
4235     * This has no meaning in the LDK, and can be NULL or any other value.
4236     */
4237    void *this_arg;
4238    /**
4239     * Returns the transaction output of a funding transaction encoded by [`short_channel_id`].
4240     * Returns an error if `genesis_hash` is for a different chain or if such a transaction output
4241     * is unknown.
4242     *
4243     * [`short_channel_id`]: https://github.com/lightningnetwork/lightning-rfc/blob/master/07-routing-gossip.md#definition-of-short_channel_id
4244     */
4245    struct LDKCResult_TxOutAccessErrorZ (*get_utxo)(const void *this_arg, const uint8_t (*genesis_hash)[32], uint64_t short_channel_id);
4246    /**
4247     * Frees any resources associated with this object given its this_arg pointer.
4248     * Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
4249     */
4250    void (*free)(void *this_arg);
4251 } LDKAccess;
4252
4253 /**
4254  * The `Listen` trait is used to be notified of when blocks have been connected or disconnected
4255  * from the chain.
4256  *
4257  * Useful when needing to replay chain data upon startup or as new chain events occur.
4258  */
4259 typedef struct LDKListen {
4260    /**
4261     * An opaque pointer which is passed to your function implementations as an argument.
4262     * This has no meaning in the LDK, and can be NULL or any other value.
4263     */
4264    void *this_arg;
4265    /**
4266     * Notifies the listener that a block was added at the given height.
4267     */
4268    void (*block_connected)(const void *this_arg, struct LDKu8slice block, uint32_t height);
4269    /**
4270     * Notifies the listener that a block was removed at the given height.
4271     */
4272    void (*block_disconnected)(const void *this_arg, const uint8_t (*header)[80], uint32_t height);
4273    /**
4274     * Frees any resources associated with this object given its this_arg pointer.
4275     * Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
4276     */
4277    void (*free)(void *this_arg);
4278 } LDKListen;
4279
4280 /**
4281  * The `Filter` trait defines behavior for indicating chain activity of interest pertaining to
4282  * channels.
4283  *
4284  * This is useful in order to have a [`Watch`] implementation convey to a chain source which
4285  * transactions to be notified of. Notification may take the form of pre-filtering blocks or, in
4286  * the case of [BIP 157]/[BIP 158], only fetching a block if the compact filter matches. If
4287  * receiving full blocks from a chain source, any further filtering is unnecessary.
4288  *
4289  * After an output has been registered, subsequent block retrievals from the chain source must not
4290  * exclude any transactions matching the new criteria nor any in-block descendants of such
4291  * transactions.
4292  *
4293  * Note that use as part of a [`Watch`] implementation involves reentrancy. Therefore, the `Filter`
4294  * should not block on I/O. Implementations should instead queue the newly monitored data to be
4295  * processed later. Then, in order to block until the data has been processed, any [`Watch`]
4296  * invocation that has called the `Filter` must return [`TemporaryFailure`].
4297  *
4298  * [`TemporaryFailure`]: channelmonitor::ChannelMonitorUpdateErr::TemporaryFailure
4299  * [BIP 157]: https://github.com/bitcoin/bips/blob/master/bip-0157.mediawiki
4300  * [BIP 158]: https://github.com/bitcoin/bips/blob/master/bip-0158.mediawiki
4301  */
4302 typedef struct LDKFilter {
4303    /**
4304     * An opaque pointer which is passed to your function implementations as an argument.
4305     * This has no meaning in the LDK, and can be NULL or any other value.
4306     */
4307    void *this_arg;
4308    /**
4309     * Registers interest in a transaction with `txid` and having an output with `script_pubkey` as
4310     * a spending condition.
4311     */
4312    void (*register_tx)(const void *this_arg, const uint8_t (*txid)[32], struct LDKu8slice script_pubkey);
4313    /**
4314     * Registers interest in spends of a transaction output identified by `outpoint` having
4315     * `script_pubkey` as the spending condition.
4316     */
4317    void (*register_output)(const void *this_arg, const struct LDKOutPoint *NONNULL_PTR outpoint, struct LDKu8slice script_pubkey);
4318    /**
4319     * Frees any resources associated with this object given its this_arg pointer.
4320     * Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
4321     */
4322    void (*free)(void *this_arg);
4323 } LDKFilter;
4324
4325 /**
4326  * `Persist` defines behavior for persisting channel monitors: this could mean
4327  * writing once to disk, and/or uploading to one or more backup services.
4328  *
4329  * Note that for every new monitor, you **must** persist the new `ChannelMonitor`
4330  * to disk/backups. And, on every update, you **must** persist either the
4331  * `ChannelMonitorUpdate` or the updated monitor itself. Otherwise, there is risk
4332  * of situations such as revoking a transaction, then crashing before this
4333  * revocation can be persisted, then unintentionally broadcasting a revoked
4334  * transaction and losing money. This is a risk because previous channel states
4335  * are toxic, so it's important that whatever channel state is persisted is
4336  * kept up-to-date.
4337  */
4338 typedef struct LDKPersist {
4339    /**
4340     * An opaque pointer which is passed to your function implementations as an argument.
4341     * This has no meaning in the LDK, and can be NULL or any other value.
4342     */
4343    void *this_arg;
4344    /**
4345     * Persist a new channel's data. The data can be stored any way you want, but
4346     * the identifier provided by Rust-Lightning is the channel's outpoint (and
4347     * it is up to you to maintain a correct mapping between the outpoint and the
4348     * stored channel data). Note that you **must** persist every new monitor to
4349     * disk. See the `Persist` trait documentation for more details.
4350     *
4351     * See [`ChannelMonitor::write`] for writing out a `ChannelMonitor`,
4352     * and [`ChannelMonitorUpdateErr`] for requirements when returning errors.
4353     */
4354    struct LDKCResult_NoneChannelMonitorUpdateErrZ (*persist_new_channel)(const void *this_arg, struct LDKOutPoint id, const struct LDKChannelMonitor *NONNULL_PTR data);
4355    /**
4356     * Update one channel's data. The provided `ChannelMonitor` has already
4357     * applied the given update.
4358     *
4359     * Note that on every update, you **must** persist either the
4360     * `ChannelMonitorUpdate` or the updated monitor itself to disk/backups. See
4361     * the `Persist` trait documentation for more details.
4362     *
4363     * If an implementer chooses to persist the updates only, they need to make
4364     * sure that all the updates are applied to the `ChannelMonitors` *before*
4365     * the set of channel monitors is given to the `ChannelManager`
4366     * deserialization routine. See [`ChannelMonitor::update_monitor`] for
4367     * applying a monitor update to a monitor. If full `ChannelMonitors` are
4368     * persisted, then there is no need to persist individual updates.
4369     *
4370     * Note that there could be a performance tradeoff between persisting complete
4371     * channel monitors on every update vs. persisting only updates and applying
4372     * them in batches. The size of each monitor grows `O(number of state updates)`
4373     * whereas updates are small and `O(1)`.
4374     *
4375     * See [`ChannelMonitor::write`] for writing out a `ChannelMonitor`,
4376     * [`ChannelMonitorUpdate::write`] for writing out an update, and
4377     * [`ChannelMonitorUpdateErr`] for requirements when returning errors.
4378     */
4379    struct LDKCResult_NoneChannelMonitorUpdateErrZ (*update_persisted_channel)(const void *this_arg, struct LDKOutPoint id, const struct LDKChannelMonitorUpdate *NONNULL_PTR update, const struct LDKChannelMonitor *NONNULL_PTR data);
4380    /**
4381     * Frees any resources associated with this object given its this_arg pointer.
4382     * Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
4383     */
4384    void (*free)(void *this_arg);
4385 } LDKPersist;
4386
4387
4388
4389 /**
4390  * An implementation of [`chain::Watch`] for monitoring channels.
4391  *
4392  * Connected and disconnected blocks must be provided to `ChainMonitor` as documented by
4393  * [`chain::Watch`]. May be used in conjunction with [`ChannelManager`] to monitor channels locally
4394  * or used independently to monitor channels remotely. See the [module-level documentation] for
4395  * details.
4396  *
4397  * [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
4398  * [module-level documentation]: crate::chain::chainmonitor
4399  */
4400 typedef struct MUST_USE_STRUCT LDKChainMonitor {
4401    /**
4402     * A pointer to the opaque Rust object.
4403     * Nearly everywhere, inner must be non-null, however in places where
4404     * the Rust equivalent takes an Option, it may be set to null to indicate None.
4405     */
4406    LDKnativeChainMonitor *inner;
4407    /**
4408     * Indicates that this is the only struct which contains the same pointer.
4409     * Rust functions which take ownership of an object provided via an argument require
4410     * this to be true and invalidate the object pointed to by inner.
4411     */
4412    bool is_owned;
4413 } LDKChainMonitor;
4414
4415
4416
4417 /**
4418  * Simple KeysInterface implementor that takes a 32-byte seed for use as a BIP 32 extended key
4419  * and derives keys from that.
4420  *
4421  * Your node_id is seed/0'
4422  * ChannelMonitor closes may use seed/1'
4423  * Cooperative closes may use seed/2'
4424  * The two close keys may be needed to claim on-chain funds!
4425  */
4426 typedef struct MUST_USE_STRUCT LDKKeysManager {
4427    /**
4428     * A pointer to the opaque Rust object.
4429     * Nearly everywhere, inner must be non-null, however in places where
4430     * the Rust equivalent takes an Option, it may be set to null to indicate None.
4431     */
4432    LDKnativeKeysManager *inner;
4433    /**
4434     * Indicates that this is the only struct which contains the same pointer.
4435     * Rust functions which take ownership of an object provided via an argument require
4436     * this to be true and invalidate the object pointed to by inner.
4437     */
4438    bool is_owned;
4439 } LDKKeysManager;
4440
4441
4442
4443 /**
4444  * Chain-related parameters used to construct a new `ChannelManager`.
4445  *
4446  * Typically, the block-specific parameters are derived from the best block hash for the network,
4447  * as a newly constructed `ChannelManager` will not have created any channels yet. These parameters
4448  * are not needed when deserializing a previously constructed `ChannelManager`.
4449  */
4450 typedef struct MUST_USE_STRUCT LDKChainParameters {
4451    /**
4452     * A pointer to the opaque Rust object.
4453     * Nearly everywhere, inner must be non-null, however in places where
4454     * the Rust equivalent takes an Option, it may be set to null to indicate None.
4455     */
4456    LDKnativeChainParameters *inner;
4457    /**
4458     * Indicates that this is the only struct which contains the same pointer.
4459     * Rust functions which take ownership of an object provided via an argument require
4460     * this to be true and invalidate the object pointed to by inner.
4461     */
4462    bool is_owned;
4463 } LDKChainParameters;
4464
4465 typedef struct LDKThreeBytes {
4466    uint8_t data[3];
4467 } LDKThreeBytes;
4468
4469 /**
4470  * A trait to describe an object which can receive channel messages.
4471  *
4472  * Messages MAY be called in parallel when they originate from different their_node_ids, however
4473  * they MUST NOT be called in parallel when the two calls have the same their_node_id.
4474  */
4475 typedef struct LDKChannelMessageHandler {
4476    /**
4477     * An opaque pointer which is passed to your function implementations as an argument.
4478     * This has no meaning in the LDK, and can be NULL or any other value.
4479     */
4480    void *this_arg;
4481    /**
4482     * Handle an incoming open_channel message from the given peer.
4483     */
4484    void (*handle_open_channel)(const void *this_arg, struct LDKPublicKey their_node_id, struct LDKInitFeatures their_features, const struct LDKOpenChannel *NONNULL_PTR msg);
4485    /**
4486     * Handle an incoming accept_channel message from the given peer.
4487     */
4488    void (*handle_accept_channel)(const void *this_arg, struct LDKPublicKey their_node_id, struct LDKInitFeatures their_features, const struct LDKAcceptChannel *NONNULL_PTR msg);
4489    /**
4490     * Handle an incoming funding_created message from the given peer.
4491     */
4492    void (*handle_funding_created)(const void *this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingCreated *NONNULL_PTR msg);
4493    /**
4494     * Handle an incoming funding_signed message from the given peer.
4495     */
4496    void (*handle_funding_signed)(const void *this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingSigned *NONNULL_PTR msg);
4497    /**
4498     * Handle an incoming funding_locked message from the given peer.
4499     */
4500    void (*handle_funding_locked)(const void *this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingLocked *NONNULL_PTR msg);
4501    /**
4502     * Handle an incoming shutdown message from the given peer.
4503     */
4504    void (*handle_shutdown)(const void *this_arg, struct LDKPublicKey their_node_id, const struct LDKInitFeatures *NONNULL_PTR their_features, const struct LDKShutdown *NONNULL_PTR msg);
4505    /**
4506     * Handle an incoming closing_signed message from the given peer.
4507     */
4508    void (*handle_closing_signed)(const void *this_arg, struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg);
4509    /**
4510     * Handle an incoming update_add_htlc message from the given peer.
4511     */
4512    void (*handle_update_add_htlc)(const void *this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateAddHTLC *NONNULL_PTR msg);
4513    /**
4514     * Handle an incoming update_fulfill_htlc message from the given peer.
4515     */
4516    void (*handle_update_fulfill_htlc)(const void *this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFulfillHTLC *NONNULL_PTR msg);
4517    /**
4518     * Handle an incoming update_fail_htlc message from the given peer.
4519     */
4520    void (*handle_update_fail_htlc)(const void *this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailHTLC *NONNULL_PTR msg);
4521    /**
4522     * Handle an incoming update_fail_malformed_htlc message from the given peer.
4523     */
4524    void (*handle_update_fail_malformed_htlc)(const void *this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR msg);
4525    /**
4526     * Handle an incoming commitment_signed message from the given peer.
4527     */
4528    void (*handle_commitment_signed)(const void *this_arg, struct LDKPublicKey their_node_id, const struct LDKCommitmentSigned *NONNULL_PTR msg);
4529    /**
4530     * Handle an incoming revoke_and_ack message from the given peer.
4531     */
4532    void (*handle_revoke_and_ack)(const void *this_arg, struct LDKPublicKey their_node_id, const struct LDKRevokeAndACK *NONNULL_PTR msg);
4533    /**
4534     * Handle an incoming update_fee message from the given peer.
4535     */
4536    void (*handle_update_fee)(const void *this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFee *NONNULL_PTR msg);
4537    /**
4538     * Handle an incoming announcement_signatures message from the given peer.
4539     */
4540    void (*handle_announcement_signatures)(const void *this_arg, struct LDKPublicKey their_node_id, const struct LDKAnnouncementSignatures *NONNULL_PTR msg);
4541    /**
4542     * Indicates a connection to the peer failed/an existing connection was lost. If no connection
4543     * is believed to be possible in the future (eg they're sending us messages we don't
4544     * understand or indicate they require unknown feature bits), no_connection_possible is set
4545     * and any outstanding channels should be failed.
4546     */
4547    void (*peer_disconnected)(const void *this_arg, struct LDKPublicKey their_node_id, bool no_connection_possible);
4548    /**
4549     * Handle a peer reconnecting, possibly generating channel_reestablish message(s).
4550     */
4551    void (*peer_connected)(const void *this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg);
4552    /**
4553     * Handle an incoming channel_reestablish message from the given peer.
4554     */
4555    void (*handle_channel_reestablish)(const void *this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg);
4556    /**
4557     * Handle an incoming channel update from the given peer.
4558     */
4559    void (*handle_channel_update)(const void *this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg);
4560    /**
4561     * Handle an incoming error message from the given peer.
4562     */
4563    void (*handle_error)(const void *this_arg, struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg);
4564    /**
4565     * Implementation of MessageSendEventsProvider for this object.
4566     */
4567    struct LDKMessageSendEventsProvider MessageSendEventsProvider;
4568    /**
4569     * Frees any resources associated with this object given its this_arg pointer.
4570     * Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
4571     */
4572    void (*free)(void *this_arg);
4573 } LDKChannelMessageHandler;
4574
4575
4576
4577 /**
4578  * Arguments for the creation of a ChannelManager that are not deserialized.
4579  *
4580  * At a high-level, the process for deserializing a ChannelManager and resuming normal operation
4581  * is:
4582  * 1) Deserialize all stored ChannelMonitors.
4583  * 2) Deserialize the ChannelManager by filling in this struct and calling:
4584  *    <(BlockHash, ChannelManager)>::read(reader, args)
4585  *    This may result in closing some Channels if the ChannelMonitor is newer than the stored
4586  *    ChannelManager state to ensure no loss of funds. Thus, transactions may be broadcasted.
4587  * 3) If you are not fetching full blocks, register all relevant ChannelMonitor outpoints the same
4588  *    way you would handle a `chain::Filter` call using ChannelMonitor::get_outputs_to_watch() and
4589  *    ChannelMonitor::get_funding_txo().
4590  * 4) Reconnect blocks on your ChannelMonitors.
4591  * 5) Disconnect/connect blocks on the ChannelManager.
4592  * 6) Move the ChannelMonitors into your local chain::Watch.
4593  *
4594  * Note that the ordering of #4-6 is not of importance, however all three must occur before you
4595  * call any other methods on the newly-deserialized ChannelManager.
4596  *
4597  * Note that because some channels may be closed during deserialization, it is critical that you
4598  * always deserialize only the latest version of a ChannelManager and ChannelMonitors available to
4599  * you. If you deserialize an old ChannelManager (during which force-closure transactions may be
4600  * broadcast), and then later deserialize a newer version of the same ChannelManager (which will
4601  * not force-close the same channels but consider them live), you may end up revoking a state for
4602  * which you've already broadcasted the transaction.
4603  */
4604 typedef struct MUST_USE_STRUCT LDKChannelManagerReadArgs {
4605    /**
4606     * A pointer to the opaque Rust object.
4607     * Nearly everywhere, inner must be non-null, however in places where
4608     * the Rust equivalent takes an Option, it may be set to null to indicate None.
4609     */
4610    LDKnativeChannelManagerReadArgs *inner;
4611    /**
4612     * Indicates that this is the only struct which contains the same pointer.
4613     * Rust functions which take ownership of an object provided via an argument require
4614     * this to be true and invalidate the object pointed to by inner.
4615     */
4616    bool is_owned;
4617 } LDKChannelManagerReadArgs;
4618
4619
4620
4621 /**
4622  * Proof that the sender knows the per-commitment secret of the previous commitment transaction.
4623  * This is used to convince the recipient that the channel is at a certain commitment
4624  * number even if they lost that data due to a local failure.  Of course, the peer may lie
4625  * and even later commitments may have been revoked.
4626  */
4627 typedef struct MUST_USE_STRUCT LDKDataLossProtect {
4628    /**
4629     * A pointer to the opaque Rust object.
4630     * Nearly everywhere, inner must be non-null, however in places where
4631     * the Rust equivalent takes an Option, it may be set to null to indicate None.
4632     */
4633    LDKnativeDataLossProtect *inner;
4634    /**
4635     * Indicates that this is the only struct which contains the same pointer.
4636     * Rust functions which take ownership of an object provided via an argument require
4637     * this to be true and invalidate the object pointed to by inner.
4638     */
4639    bool is_owned;
4640 } LDKDataLossProtect;
4641
4642 /**
4643  * A trait to describe an object which can receive routing messages.
4644  *
4645  * # Implementor DoS Warnings
4646  *
4647  * For `gossip_queries` messages there are potential DoS vectors when handling
4648  * inbound queries. Implementors using an on-disk network graph should be aware of
4649  * repeated disk I/O for queries accessing different parts of the network graph.
4650  */
4651 typedef struct LDKRoutingMessageHandler {
4652    /**
4653     * An opaque pointer which is passed to your function implementations as an argument.
4654     * This has no meaning in the LDK, and can be NULL or any other value.
4655     */
4656    void *this_arg;
4657    /**
4658     * Handle an incoming node_announcement message, returning true if it should be forwarded on,
4659     * false or returning an Err otherwise.
4660     */
4661    struct LDKCResult_boolLightningErrorZ (*handle_node_announcement)(const void *this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg);
4662    /**
4663     * Handle a channel_announcement message, returning true if it should be forwarded on, false
4664     * or returning an Err otherwise.
4665     */
4666    struct LDKCResult_boolLightningErrorZ (*handle_channel_announcement)(const void *this_arg, const struct LDKChannelAnnouncement *NONNULL_PTR msg);
4667    /**
4668     * Handle an incoming channel_update message, returning true if it should be forwarded on,
4669     * false or returning an Err otherwise.
4670     */
4671    struct LDKCResult_boolLightningErrorZ (*handle_channel_update)(const void *this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg);
4672    /**
4673     * Handle some updates to the route graph that we learned due to an outbound failed payment.
4674     */
4675    void (*handle_htlc_fail_channel_update)(const void *this_arg, const struct LDKHTLCFailChannelUpdate *NONNULL_PTR update);
4676    /**
4677     * Gets a subset of the channel announcements and updates required to dump our routing table
4678     * to a remote node, starting at the short_channel_id indicated by starting_point and
4679     * including the batch_amount entries immediately higher in numerical value than starting_point.
4680     */
4681    struct LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ (*get_next_channel_announcements)(const void *this_arg, uint64_t starting_point, uint8_t batch_amount);
4682    /**
4683     * Gets a subset of the node announcements required to dump our routing table to a remote node,
4684     * starting at the node *after* the provided publickey and including batch_amount entries
4685     * immediately higher (as defined by <PublicKey as Ord>::cmp) than starting_point.
4686     * If None is provided for starting_point, we start at the first node.
4687     */
4688    struct LDKCVec_NodeAnnouncementZ (*get_next_node_announcements)(const void *this_arg, struct LDKPublicKey starting_point, uint8_t batch_amount);
4689    /**
4690     * Called when a connection is established with a peer. This can be used to
4691     * perform routing table synchronization using a strategy defined by the
4692     * implementor.
4693     */
4694    void (*sync_routing_table)(const void *this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init);
4695    /**
4696     * Handles the reply of a query we initiated to learn about channels
4697     * for a given range of blocks. We can expect to receive one or more
4698     * replies to a single query.
4699     */
4700    struct LDKCResult_NoneLightningErrorZ (*handle_reply_channel_range)(const void *this_arg, struct LDKPublicKey their_node_id, struct LDKReplyChannelRange msg);
4701    /**
4702     * Handles the reply of a query we initiated asking for routing gossip
4703     * messages for a list of channels. We should receive this message when
4704     * a node has completed its best effort to send us the pertaining routing
4705     * gossip messages.
4706     */
4707    struct LDKCResult_NoneLightningErrorZ (*handle_reply_short_channel_ids_end)(const void *this_arg, struct LDKPublicKey their_node_id, struct LDKReplyShortChannelIdsEnd msg);
4708    /**
4709     * Handles when a peer asks us to send a list of short_channel_ids
4710     * for the requested range of blocks.
4711     */
4712    struct LDKCResult_NoneLightningErrorZ (*handle_query_channel_range)(const void *this_arg, struct LDKPublicKey their_node_id, struct LDKQueryChannelRange msg);
4713    /**
4714     * Handles when a peer asks us to send routing gossip messages for a
4715     * list of short_channel_ids.
4716     */
4717    struct LDKCResult_NoneLightningErrorZ (*handle_query_short_channel_ids)(const void *this_arg, struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg);
4718    /**
4719     * Implementation of MessageSendEventsProvider for this object.
4720     */
4721    struct LDKMessageSendEventsProvider MessageSendEventsProvider;
4722    /**
4723     * Frees any resources associated with this object given its this_arg pointer.
4724     * Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
4725     */
4726    void (*free)(void *this_arg);
4727 } LDKRoutingMessageHandler;
4728
4729
4730
4731 /**
4732  * A dummy struct which implements `RoutingMessageHandler` without storing any routing information
4733  * or doing any processing. You can provide one of these as the route_handler in a MessageHandler.
4734  */
4735 typedef struct MUST_USE_STRUCT LDKIgnoringMessageHandler {
4736    /**
4737     * A pointer to the opaque Rust object.
4738     * Nearly everywhere, inner must be non-null, however in places where
4739     * the Rust equivalent takes an Option, it may be set to null to indicate None.
4740     */
4741    LDKnativeIgnoringMessageHandler *inner;
4742    /**
4743     * Indicates that this is the only struct which contains the same pointer.
4744     * Rust functions which take ownership of an object provided via an argument require
4745     * this to be true and invalidate the object pointed to by inner.
4746     */
4747    bool is_owned;
4748 } LDKIgnoringMessageHandler;
4749
4750
4751
4752 /**
4753  * A dummy struct which implements `ChannelMessageHandler` without having any channels.
4754  * You can provide one of these as the route_handler in a MessageHandler.
4755  */
4756 typedef struct MUST_USE_STRUCT LDKErroringMessageHandler {
4757    /**
4758     * A pointer to the opaque Rust object.
4759     * Nearly everywhere, inner must be non-null, however in places where
4760     * the Rust equivalent takes an Option, it may be set to null to indicate None.
4761     */
4762    LDKnativeErroringMessageHandler *inner;
4763    /**
4764     * Indicates that this is the only struct which contains the same pointer.
4765     * Rust functions which take ownership of an object provided via an argument require
4766     * this to be true and invalidate the object pointed to by inner.
4767     */
4768    bool is_owned;
4769 } LDKErroringMessageHandler;
4770
4771
4772
4773 /**
4774  * Provides references to trait impls which handle different types of messages.
4775  */
4776 typedef struct MUST_USE_STRUCT LDKMessageHandler {
4777    /**
4778     * A pointer to the opaque Rust object.
4779     * Nearly everywhere, inner must be non-null, however in places where
4780     * the Rust equivalent takes an Option, it may be set to null to indicate None.
4781     */
4782    LDKnativeMessageHandler *inner;
4783    /**
4784     * Indicates that this is the only struct which contains the same pointer.
4785     * Rust functions which take ownership of an object provided via an argument require
4786     * this to be true and invalidate the object pointed to by inner.
4787     */
4788    bool is_owned;
4789 } LDKMessageHandler;
4790
4791 /**
4792  * Provides an object which can be used to send data to and which uniquely identifies a connection
4793  * to a remote host. You will need to be able to generate multiple of these which meet Eq and
4794  * implement Hash to meet the PeerManager API.
4795  *
4796  * For efficiency, Clone should be relatively cheap for this type.
4797  *
4798  * You probably want to just extend an int and put a file descriptor in a struct and implement
4799  * send_data. Note that if you are using a higher-level net library that may call close() itself,
4800  * be careful to ensure you don't have races whereby you might register a new connection with an
4801  * fd which is the same as a previous one which has yet to be removed via
4802  * PeerManager::socket_disconnected().
4803  */
4804 typedef struct LDKSocketDescriptor {
4805    /**
4806     * An opaque pointer which is passed to your function implementations as an argument.
4807     * This has no meaning in the LDK, and can be NULL or any other value.
4808     */
4809    void *this_arg;
4810    /**
4811     * Attempts to send some data from the given slice to the peer.
4812     *
4813     * Returns the amount of data which was sent, possibly 0 if the socket has since disconnected.
4814     * Note that in the disconnected case, socket_disconnected must still fire and further write
4815     * attempts may occur until that time.
4816     *
4817     * If the returned size is smaller than data.len(), a write_available event must
4818     * trigger the next time more data can be written. Additionally, until the a send_data event
4819     * completes fully, no further read_events should trigger on the same peer!
4820     *
4821     * If a read_event on this descriptor had previously returned true (indicating that read
4822     * events should be paused to prevent DoS in the send buffer), resume_read may be set
4823     * indicating that read events on this descriptor should resume. A resume_read of false does
4824     * *not* imply that further read events should be paused.
4825     */
4826    uintptr_t (*send_data)(void *this_arg, struct LDKu8slice data, bool resume_read);
4827    /**
4828     * Disconnect the socket pointed to by this SocketDescriptor. Once this function returns, no
4829     * more calls to write_buffer_space_avail, read_event or socket_disconnected may be made with
4830     * this descriptor. No socket_disconnected call should be generated as a result of this call,
4831     * though races may occur whereby disconnect_socket is called after a call to
4832     * socket_disconnected but prior to socket_disconnected returning.
4833     */
4834    void (*disconnect_socket)(void *this_arg);
4835    /**
4836     * Checks if two objects are equal given this object's this_arg pointer and another object.
4837     */
4838    bool (*eq)(const void *this_arg, const struct LDKSocketDescriptor *NONNULL_PTR other_arg);
4839    /**
4840     * Calculate a succinct non-cryptographic hash for an object given its this_arg pointer.
4841     * This is used, for example, for inclusion of this object in a hash map.
4842     */
4843    uint64_t (*hash)(const void *this_arg);
4844    /**
4845     * Creates a copy of the object pointed to by this_arg, for a copy of this SocketDescriptor.
4846     * Note that the ultimate copy of the SocketDescriptor will have all function pointers the same as the original.
4847     * May be NULL if no action needs to be taken, the this_arg pointer will be copied into the new SocketDescriptor.
4848     */
4849    void *(*clone)(const void *this_arg);
4850    /**
4851     * Frees any resources associated with this object given its this_arg pointer.
4852     * Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
4853     */
4854    void (*free)(void *this_arg);
4855 } LDKSocketDescriptor;
4856
4857
4858
4859 /**
4860  * A PeerManager manages a set of peers, described by their SocketDescriptor and marshalls socket
4861  * events into messages which it passes on to its MessageHandlers.
4862  *
4863  * Rather than using a plain PeerManager, it is preferable to use either a SimpleArcPeerManager
4864  * a SimpleRefPeerManager, for conciseness. See their documentation for more details, but
4865  * essentially you should default to using a SimpleRefPeerManager, and use a
4866  * SimpleArcPeerManager when you require a PeerManager with a static lifetime, such as when
4867  * you're using lightning-net-tokio.
4868  */
4869 typedef struct MUST_USE_STRUCT LDKPeerManager {
4870    /**
4871     * A pointer to the opaque Rust object.
4872     * Nearly everywhere, inner must be non-null, however in places where
4873     * the Rust equivalent takes an Option, it may be set to null to indicate None.
4874     */
4875    LDKnativePeerManager *inner;
4876    /**
4877     * Indicates that this is the only struct which contains the same pointer.
4878     * Rust functions which take ownership of an object provided via an argument require
4879     * this to be true and invalidate the object pointed to by inner.
4880     */
4881    bool is_owned;
4882 } LDKPeerManager;
4883
4884
4885
4886 /**
4887  * Static channel fields used to build transactions given per-commitment fields, organized by
4888  * broadcaster/countersignatory.
4889  *
4890  * This is derived from the holder/counterparty-organized ChannelTransactionParameters via the
4891  * as_holder_broadcastable and as_counterparty_broadcastable functions.
4892  */
4893 typedef struct MUST_USE_STRUCT LDKDirectedChannelTransactionParameters {
4894    /**
4895     * A pointer to the opaque Rust object.
4896     * Nearly everywhere, inner must be non-null, however in places where
4897     * the Rust equivalent takes an Option, it may be set to null to indicate None.
4898     */
4899    LDKnativeDirectedChannelTransactionParameters *inner;
4900    /**
4901     * Indicates that this is the only struct which contains the same pointer.
4902     * Rust functions which take ownership of an object provided via an argument require
4903     * this to be true and invalidate the object pointed to by inner.
4904     */
4905    bool is_owned;
4906 } LDKDirectedChannelTransactionParameters;
4907
4908
4909
4910 /**
4911  * A simple newtype for RwLockReadGuard<'a, NetworkGraph>.
4912  * This exists only to make accessing a RwLock<NetworkGraph> possible from
4913  * the C bindings, as it can be done directly in Rust code.
4914  */
4915 typedef struct MUST_USE_STRUCT LDKLockedNetworkGraph {
4916    /**
4917     * A pointer to the opaque Rust object.
4918     * Nearly everywhere, inner must be non-null, however in places where
4919     * the Rust equivalent takes an Option, it may be set to null to indicate None.
4920     */
4921    LDKnativeLockedNetworkGraph *inner;
4922    /**
4923     * Indicates that this is the only struct which contains the same pointer.
4924     * Rust functions which take ownership of an object provided via an argument require
4925     * this to be true and invalidate the object pointed to by inner.
4926     */
4927    bool is_owned;
4928 } LDKLockedNetworkGraph;
4929
4930
4931
4932 /**
4933  * Receives and validates network updates from peers,
4934  * stores authentic and relevant data as a network graph.
4935  * This network graph is then used for routing payments.
4936  * Provides interface to help with initial routing sync by
4937  * serving historical announcements.
4938  */
4939 typedef struct MUST_USE_STRUCT LDKNetGraphMsgHandler {
4940    /**
4941     * A pointer to the opaque Rust object.
4942     * Nearly everywhere, inner must be non-null, however in places where
4943     * the Rust equivalent takes an Option, it may be set to null to indicate None.
4944     */
4945    LDKnativeNetGraphMsgHandler *inner;
4946    /**
4947     * Indicates that this is the only struct which contains the same pointer.
4948     * Rust functions which take ownership of an object provided via an argument require
4949     * this to be true and invalidate the object pointed to by inner.
4950     */
4951    bool is_owned;
4952 } LDKNetGraphMsgHandler;
4953
4954 extern const uintptr_t MAX_BUF_SIZE;
4955
4956 extern const uint64_t MIN_RELAY_FEE_SAT_PER_1000_WEIGHT;
4957
4958 extern const uint64_t CLOSED_CHANNEL_UPDATE_ID;
4959
4960 extern const uint16_t BREAKDOWN_TIMEOUT;
4961
4962 extern const uint16_t MIN_CLTV_EXPIRY_DELTA;
4963
4964 extern const uintptr_t REVOKEABLE_REDEEMSCRIPT_MAX_LENGTH;
4965
4966 void Transaction_free(struct LDKTransaction _res);
4967
4968 void TxOut_free(struct LDKTxOut _res);
4969
4970 struct LDKTxOut TxOut_clone(const struct LDKTxOut *NONNULL_PTR orig);
4971
4972 struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_ok(struct LDKSecretKey o);
4973
4974 struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_err(enum LDKSecp256k1Error e);
4975
4976 void CResult_SecretKeyErrorZ_free(struct LDKCResult_SecretKeyErrorZ _res);
4977
4978 struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_ok(struct LDKPublicKey o);
4979
4980 struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_err(enum LDKSecp256k1Error e);
4981
4982 void CResult_PublicKeyErrorZ_free(struct LDKCResult_PublicKeyErrorZ _res);
4983
4984 struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_ok(struct LDKTxCreationKeys o);
4985
4986 struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_err(struct LDKDecodeError e);
4987
4988 void CResult_TxCreationKeysDecodeErrorZ_free(struct LDKCResult_TxCreationKeysDecodeErrorZ _res);
4989
4990 struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_clone(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR orig);
4991
4992 struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_ok(struct LDKChannelPublicKeys o);
4993
4994 struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_err(struct LDKDecodeError e);
4995
4996 void CResult_ChannelPublicKeysDecodeErrorZ_free(struct LDKCResult_ChannelPublicKeysDecodeErrorZ _res);
4997
4998 struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_clone(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR orig);
4999
5000 struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_ok(struct LDKTxCreationKeys o);
5001
5002 struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_err(enum LDKSecp256k1Error e);
5003
5004 void CResult_TxCreationKeysErrorZ_free(struct LDKCResult_TxCreationKeysErrorZ _res);
5005
5006 struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(struct LDKHTLCOutputInCommitment o);
5007
5008 struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_err(struct LDKDecodeError e);
5009
5010 void CResult_HTLCOutputInCommitmentDecodeErrorZ_free(struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ _res);
5011
5012 struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR orig);
5013
5014 struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(struct LDKCounterpartyChannelTransactionParameters o);
5015
5016 struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
5017
5018 void CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ _res);
5019
5020 struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
5021
5022 struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_ok(struct LDKChannelTransactionParameters o);
5023
5024 struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
5025
5026 void CResult_ChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_ChannelTransactionParametersDecodeErrorZ _res);
5027
5028 struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
5029
5030 void CVec_SignatureZ_free(struct LDKCVec_SignatureZ _res);
5031
5032 struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_ok(struct LDKHolderCommitmentTransaction o);
5033
5034 struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
5035
5036 void CResult_HolderCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ _res);
5037
5038 struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
5039
5040 struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(struct LDKBuiltCommitmentTransaction o);
5041
5042 struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
5043
5044 void CResult_BuiltCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ _res);
5045
5046 struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
5047
5048 struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_ok(struct LDKCommitmentTransaction o);
5049
5050 struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
5051
5052 void CResult_CommitmentTransactionDecodeErrorZ_free(struct LDKCResult_CommitmentTransactionDecodeErrorZ _res);
5053
5054 struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
5055
5056 struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_ok(struct LDKTrustedCommitmentTransaction o);
5057
5058 struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_err(void);
5059
5060 void CResult_TrustedCommitmentTransactionNoneZ_free(struct LDKCResult_TrustedCommitmentTransactionNoneZ _res);
5061
5062 struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_ok(struct LDKCVec_SignatureZ o);
5063
5064 struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_err(void);
5065
5066 void CResult_CVec_SignatureZNoneZ_free(struct LDKCResult_CVec_SignatureZNoneZ _res);
5067
5068 struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_clone(const struct LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR orig);
5069
5070 void CVec_MessageSendEventZ_free(struct LDKCVec_MessageSendEventZ _res);
5071
5072 struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_ok(bool o);
5073
5074 struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_err(struct LDKLightningError e);
5075
5076 void CResult_boolLightningErrorZ_free(struct LDKCResult_boolLightningErrorZ _res);
5077
5078 struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_clone(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR orig);
5079
5080 struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(const struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR orig);
5081
5082 struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(struct LDKChannelAnnouncement a, struct LDKChannelUpdate b, struct LDKChannelUpdate c);
5083
5084 void C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res);
5085
5086 void CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(struct LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res);
5087
5088 void CVec_NodeAnnouncementZ_free(struct LDKCVec_NodeAnnouncementZ _res);
5089
5090 struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_ok(void);
5091
5092 struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_err(struct LDKLightningError e);
5093
5094 void CResult_NoneLightningErrorZ_free(struct LDKCResult_NoneLightningErrorZ _res);
5095
5096 struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_clone(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR orig);
5097
5098 void CVec_PublicKeyZ_free(struct LDKCVec_PublicKeyZ _res);
5099
5100 void CVec_u8Z_free(struct LDKCVec_u8Z _res);
5101
5102 struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_ok(struct LDKCVec_u8Z o);
5103
5104 struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_err(struct LDKPeerHandleError e);
5105
5106 void CResult_CVec_u8ZPeerHandleErrorZ_free(struct LDKCResult_CVec_u8ZPeerHandleErrorZ _res);
5107
5108 struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_clone(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR orig);
5109
5110 struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_ok(void);
5111
5112 struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_err(struct LDKPeerHandleError e);
5113
5114 void CResult_NonePeerHandleErrorZ_free(struct LDKCResult_NonePeerHandleErrorZ _res);
5115
5116 struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_clone(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR orig);
5117
5118 struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_ok(bool o);
5119
5120 struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_err(struct LDKPeerHandleError e);
5121
5122 void CResult_boolPeerHandleErrorZ_free(struct LDKCResult_boolPeerHandleErrorZ _res);
5123
5124 struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_clone(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR orig);
5125
5126 struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_ok(struct LDKInitFeatures o);
5127
5128 struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
5129
5130 void CResult_InitFeaturesDecodeErrorZ_free(struct LDKCResult_InitFeaturesDecodeErrorZ _res);
5131
5132 struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_ok(struct LDKNodeFeatures o);
5133
5134 struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
5135
5136 void CResult_NodeFeaturesDecodeErrorZ_free(struct LDKCResult_NodeFeaturesDecodeErrorZ _res);
5137
5138 struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_ok(struct LDKChannelFeatures o);
5139
5140 struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
5141
5142 void CResult_ChannelFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelFeaturesDecodeErrorZ _res);
5143
5144 struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_ok(struct LDKInvoiceFeatures o);
5145
5146 struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
5147
5148 void CResult_InvoiceFeaturesDecodeErrorZ_free(struct LDKCResult_InvoiceFeaturesDecodeErrorZ _res);
5149
5150 struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_ok(struct LDKChannelConfig o);
5151
5152 struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_err(struct LDKDecodeError e);
5153
5154 void CResult_ChannelConfigDecodeErrorZ_free(struct LDKCResult_ChannelConfigDecodeErrorZ _res);
5155
5156 struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_clone(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR orig);
5157
5158 struct LDKCResult_DirectionalChannelInfoDecodeErrorZ CResult_DirectionalChannelInfoDecodeErrorZ_ok(struct LDKDirectionalChannelInfo o);
5159
5160 struct LDKCResult_DirectionalChannelInfoDecodeErrorZ CResult_DirectionalChannelInfoDecodeErrorZ_err(struct LDKDecodeError e);
5161
5162 void CResult_DirectionalChannelInfoDecodeErrorZ_free(struct LDKCResult_DirectionalChannelInfoDecodeErrorZ _res);
5163
5164 struct LDKCResult_DirectionalChannelInfoDecodeErrorZ CResult_DirectionalChannelInfoDecodeErrorZ_clone(const struct LDKCResult_DirectionalChannelInfoDecodeErrorZ *NONNULL_PTR orig);
5165
5166 struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_ok(struct LDKChannelInfo o);
5167
5168 struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_err(struct LDKDecodeError e);
5169
5170 void CResult_ChannelInfoDecodeErrorZ_free(struct LDKCResult_ChannelInfoDecodeErrorZ _res);
5171
5172 struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR orig);
5173
5174 struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_ok(struct LDKRoutingFees o);
5175
5176 struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_err(struct LDKDecodeError e);
5177
5178 void CResult_RoutingFeesDecodeErrorZ_free(struct LDKCResult_RoutingFeesDecodeErrorZ _res);
5179
5180 struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_clone(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR orig);
5181
5182 void CVec_NetAddressZ_free(struct LDKCVec_NetAddressZ _res);
5183
5184 struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_ok(struct LDKNodeAnnouncementInfo o);
5185
5186 struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_err(struct LDKDecodeError e);
5187
5188 void CResult_NodeAnnouncementInfoDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ _res);
5189
5190 struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR orig);
5191
5192 void CVec_u64Z_free(struct LDKCVec_u64Z _res);
5193
5194 struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_ok(struct LDKNodeInfo o);
5195
5196 struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_err(struct LDKDecodeError e);
5197
5198 void CResult_NodeInfoDecodeErrorZ_free(struct LDKCResult_NodeInfoDecodeErrorZ _res);
5199
5200 struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_clone(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR orig);
5201
5202 struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_ok(struct LDKNetworkGraph o);
5203
5204 struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_err(struct LDKDecodeError e);
5205
5206 void CResult_NetworkGraphDecodeErrorZ_free(struct LDKCResult_NetworkGraphDecodeErrorZ _res);
5207
5208 struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_clone(const struct LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR orig);
5209
5210 struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_new(uintptr_t a, struct LDKTransaction b);
5211
5212 void C2Tuple_usizeTransactionZ_free(struct LDKC2Tuple_usizeTransactionZ _res);
5213
5214 void CVec_C2Tuple_usizeTransactionZZ_free(struct LDKCVec_C2Tuple_usizeTransactionZZ _res);
5215
5216 struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_ok(void);
5217
5218 struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_err(enum LDKChannelMonitorUpdateErr e);
5219
5220 void CResult_NoneChannelMonitorUpdateErrZ_free(struct LDKCResult_NoneChannelMonitorUpdateErrZ _res);
5221
5222 struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_clone(const struct LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR orig);
5223
5224 void CVec_MonitorEventZ_free(struct LDKCVec_MonitorEventZ _res);
5225
5226 void CVec_EventZ_free(struct LDKCVec_EventZ _res);
5227
5228 struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_ok(struct LDKOutPoint o);
5229
5230 struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_err(struct LDKDecodeError e);
5231
5232 void CResult_OutPointDecodeErrorZ_free(struct LDKCResult_OutPointDecodeErrorZ _res);
5233
5234 struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_clone(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR orig);
5235
5236 struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_ok(struct LDKChannelMonitorUpdate o);
5237
5238 struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_err(struct LDKDecodeError e);
5239
5240 void CResult_ChannelMonitorUpdateDecodeErrorZ_free(struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ _res);
5241
5242 struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR orig);
5243
5244 struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_ok(struct LDKHTLCUpdate o);
5245
5246 struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_err(struct LDKDecodeError e);
5247
5248 void CResult_HTLCUpdateDecodeErrorZ_free(struct LDKCResult_HTLCUpdateDecodeErrorZ _res);
5249
5250 struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_clone(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR orig);
5251
5252 struct LDKCResult_NoneMonitorUpdateErrorZ CResult_NoneMonitorUpdateErrorZ_ok(void);
5253
5254 struct LDKCResult_NoneMonitorUpdateErrorZ CResult_NoneMonitorUpdateErrorZ_err(struct LDKMonitorUpdateError e);
5255
5256 void CResult_NoneMonitorUpdateErrorZ_free(struct LDKCResult_NoneMonitorUpdateErrorZ _res);
5257
5258 struct LDKCResult_NoneMonitorUpdateErrorZ CResult_NoneMonitorUpdateErrorZ_clone(const struct LDKCResult_NoneMonitorUpdateErrorZ *NONNULL_PTR orig);
5259
5260 struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_clone(const struct LDKC2Tuple_OutPointScriptZ *NONNULL_PTR orig);
5261
5262 struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_new(struct LDKOutPoint a, struct LDKCVec_u8Z b);
5263
5264 void C2Tuple_OutPointScriptZ_free(struct LDKC2Tuple_OutPointScriptZ _res);
5265
5266 struct LDKC2Tuple_u32ScriptZ C2Tuple_u32ScriptZ_clone(const struct LDKC2Tuple_u32ScriptZ *NONNULL_PTR orig);
5267
5268 struct LDKC2Tuple_u32ScriptZ C2Tuple_u32ScriptZ_new(uint32_t a, struct LDKCVec_u8Z b);
5269
5270 void C2Tuple_u32ScriptZ_free(struct LDKC2Tuple_u32ScriptZ _res);
5271
5272 void CVec_C2Tuple_u32ScriptZZ_free(struct LDKCVec_C2Tuple_u32ScriptZZ _res);
5273
5274 struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32ScriptZZ b);
5275
5276 void C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ _res);
5277
5278 void CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ _res);
5279
5280 void CVec_TransactionZ_free(struct LDKCVec_TransactionZ _res);
5281
5282 struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_clone(const struct LDKC2Tuple_u32TxOutZ *NONNULL_PTR orig);
5283
5284 struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_new(uint32_t a, struct LDKTxOut b);
5285
5286 void C2Tuple_u32TxOutZ_free(struct LDKC2Tuple_u32TxOutZ _res);
5287
5288 void CVec_C2Tuple_u32TxOutZZ_free(struct LDKCVec_C2Tuple_u32TxOutZZ _res);
5289
5290 struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32TxOutZZ b);
5291
5292 void C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ _res);
5293
5294 void CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ _res);
5295
5296 struct LDKC2Tuple_BlockHashChannelMonitorZ C2Tuple_BlockHashChannelMonitorZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelMonitor b);
5297
5298 void C2Tuple_BlockHashChannelMonitorZ_free(struct LDKC2Tuple_BlockHashChannelMonitorZ _res);
5299
5300 struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelMonitorZ o);
5301
5302 struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(struct LDKDecodeError e);
5303
5304 void CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ _res);
5305
5306 void CVec_SpendableOutputDescriptorZ_free(struct LDKCVec_SpendableOutputDescriptorZ _res);
5307
5308 struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_ok(struct LDKTxOut o);
5309
5310 struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_err(enum LDKAccessError e);
5311
5312 void CResult_TxOutAccessErrorZ_free(struct LDKCResult_TxOutAccessErrorZ _res);
5313
5314 struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_clone(const struct LDKCResult_TxOutAccessErrorZ *NONNULL_PTR orig);
5315
5316 struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_ok(void);
5317
5318 struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_err(struct LDKAPIError e);
5319
5320 void CResult_NoneAPIErrorZ_free(struct LDKCResult_NoneAPIErrorZ _res);
5321
5322 struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_clone(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR orig);
5323
5324 void CVec_CResult_NoneAPIErrorZZ_free(struct LDKCVec_CResult_NoneAPIErrorZZ _res);
5325
5326 void CVec_APIErrorZ_free(struct LDKCVec_APIErrorZ _res);
5327
5328 void CVec_ChannelDetailsZ_free(struct LDKCVec_ChannelDetailsZ _res);
5329
5330 struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_ok(void);
5331
5332 struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
5333
5334 void CResult_NonePaymentSendFailureZ_free(struct LDKCResult_NonePaymentSendFailureZ _res);
5335
5336 struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_clone(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR orig);
5337
5338 void CVec_ChannelMonitorZ_free(struct LDKCVec_ChannelMonitorZ _res);
5339
5340 struct LDKC2Tuple_BlockHashChannelManagerZ C2Tuple_BlockHashChannelManagerZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelManager b);
5341
5342 void C2Tuple_BlockHashChannelManagerZ_free(struct LDKC2Tuple_BlockHashChannelManagerZ _res);
5343
5344 struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelManagerZ o);
5345
5346 struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(struct LDKDecodeError e);
5347
5348 void CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ _res);
5349
5350 struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_ok(struct LDKSpendableOutputDescriptor o);
5351
5352 struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
5353
5354 void CResult_SpendableOutputDescriptorDecodeErrorZ_free(struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ _res);
5355
5356 struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
5357
5358 struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_clone(const struct LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR orig);
5359
5360 struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_new(struct LDKSignature a, struct LDKCVec_SignatureZ b);
5361
5362 void C2Tuple_SignatureCVec_SignatureZZ_free(struct LDKC2Tuple_SignatureCVec_SignatureZZ _res);
5363
5364 struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(struct LDKC2Tuple_SignatureCVec_SignatureZZ o);
5365
5366 struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(void);
5367
5368 void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ _res);
5369
5370 struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(const struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR orig);
5371
5372 struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_ok(struct LDKSignature o);
5373
5374 struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_err(void);
5375
5376 void CResult_SignatureNoneZ_free(struct LDKCResult_SignatureNoneZ _res);
5377
5378 struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_clone(const struct LDKCResult_SignatureNoneZ *NONNULL_PTR orig);
5379
5380 struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_ok(struct LDKSign o);
5381
5382 struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_err(struct LDKDecodeError e);
5383
5384 void CResult_SignDecodeErrorZ_free(struct LDKCResult_SignDecodeErrorZ _res);
5385
5386 struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_clone(const struct LDKCResult_SignDecodeErrorZ *NONNULL_PTR orig);
5387
5388 void CVec_CVec_u8ZZ_free(struct LDKCVec_CVec_u8ZZ _res);
5389
5390 struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_ok(struct LDKCVec_CVec_u8ZZ o);
5391
5392 struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_err(void);
5393
5394 void CResult_CVec_CVec_u8ZZNoneZ_free(struct LDKCResult_CVec_CVec_u8ZZNoneZ _res);
5395
5396 struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_clone(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR orig);
5397
5398 struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_ok(struct LDKInMemorySigner o);
5399
5400 struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_err(struct LDKDecodeError e);
5401
5402 void CResult_InMemorySignerDecodeErrorZ_free(struct LDKCResult_InMemorySignerDecodeErrorZ _res);
5403
5404 struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_clone(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR orig);
5405
5406 void CVec_TxOutZ_free(struct LDKCVec_TxOutZ _res);
5407
5408 struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_ok(struct LDKTransaction o);
5409
5410 struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_err(void);
5411
5412 void CResult_TransactionNoneZ_free(struct LDKCResult_TransactionNoneZ _res);
5413
5414 void CVec_RouteHopZ_free(struct LDKCVec_RouteHopZ _res);
5415
5416 void CVec_CVec_RouteHopZZ_free(struct LDKCVec_CVec_RouteHopZZ _res);
5417
5418 struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_ok(struct LDKRoute o);
5419
5420 struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_err(struct LDKDecodeError e);
5421
5422 void CResult_RouteDecodeErrorZ_free(struct LDKCResult_RouteDecodeErrorZ _res);
5423
5424 struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_clone(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR orig);
5425
5426 void CVec_RouteHintZ_free(struct LDKCVec_RouteHintZ _res);
5427
5428 struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_ok(struct LDKRoute o);
5429
5430 struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_err(struct LDKLightningError e);
5431
5432 void CResult_RouteLightningErrorZ_free(struct LDKCResult_RouteLightningErrorZ _res);
5433
5434 struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_clone(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR orig);
5435
5436 struct LDKCResult_NetAddressu8Z CResult_NetAddressu8Z_ok(struct LDKNetAddress o);
5437
5438 struct LDKCResult_NetAddressu8Z CResult_NetAddressu8Z_err(uint8_t e);
5439
5440 void CResult_NetAddressu8Z_free(struct LDKCResult_NetAddressu8Z _res);
5441
5442 struct LDKCResult_NetAddressu8Z CResult_NetAddressu8Z_clone(const struct LDKCResult_NetAddressu8Z *NONNULL_PTR orig);
5443
5444 struct LDKCResult_CResult_NetAddressu8ZDecodeErrorZ CResult_CResult_NetAddressu8ZDecodeErrorZ_ok(struct LDKCResult_NetAddressu8Z o);
5445
5446 struct LDKCResult_CResult_NetAddressu8ZDecodeErrorZ CResult_CResult_NetAddressu8ZDecodeErrorZ_err(struct LDKDecodeError e);
5447
5448 void CResult_CResult_NetAddressu8ZDecodeErrorZ_free(struct LDKCResult_CResult_NetAddressu8ZDecodeErrorZ _res);
5449
5450 struct LDKCResult_CResult_NetAddressu8ZDecodeErrorZ CResult_CResult_NetAddressu8ZDecodeErrorZ_clone(const struct LDKCResult_CResult_NetAddressu8ZDecodeErrorZ *NONNULL_PTR orig);
5451
5452 void CVec_UpdateAddHTLCZ_free(struct LDKCVec_UpdateAddHTLCZ _res);
5453
5454 void CVec_UpdateFulfillHTLCZ_free(struct LDKCVec_UpdateFulfillHTLCZ _res);
5455
5456 void CVec_UpdateFailHTLCZ_free(struct LDKCVec_UpdateFailHTLCZ _res);
5457
5458 void CVec_UpdateFailMalformedHTLCZ_free(struct LDKCVec_UpdateFailMalformedHTLCZ _res);
5459
5460 struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_ok(struct LDKAcceptChannel o);
5461
5462 struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_err(struct LDKDecodeError e);
5463
5464 void CResult_AcceptChannelDecodeErrorZ_free(struct LDKCResult_AcceptChannelDecodeErrorZ _res);
5465
5466 struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_clone(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR orig);
5467
5468 struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_ok(struct LDKAnnouncementSignatures o);
5469
5470 struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_err(struct LDKDecodeError e);
5471
5472 void CResult_AnnouncementSignaturesDecodeErrorZ_free(struct LDKCResult_AnnouncementSignaturesDecodeErrorZ _res);
5473
5474 struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_clone(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR orig);
5475
5476 struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_ok(struct LDKChannelReestablish o);
5477
5478 struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_err(struct LDKDecodeError e);
5479
5480 void CResult_ChannelReestablishDecodeErrorZ_free(struct LDKCResult_ChannelReestablishDecodeErrorZ _res);
5481
5482 struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_clone(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR orig);
5483
5484 struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_ok(struct LDKClosingSigned o);
5485
5486 struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_err(struct LDKDecodeError e);
5487
5488 void CResult_ClosingSignedDecodeErrorZ_free(struct LDKCResult_ClosingSignedDecodeErrorZ _res);
5489
5490 struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR orig);
5491
5492 struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_ok(struct LDKCommitmentSigned o);
5493
5494 struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_err(struct LDKDecodeError e);
5495
5496 void CResult_CommitmentSignedDecodeErrorZ_free(struct LDKCResult_CommitmentSignedDecodeErrorZ _res);
5497
5498 struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_clone(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR orig);
5499
5500 struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_ok(struct LDKFundingCreated o);
5501
5502 struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_err(struct LDKDecodeError e);
5503
5504 void CResult_FundingCreatedDecodeErrorZ_free(struct LDKCResult_FundingCreatedDecodeErrorZ _res);
5505
5506 struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_clone(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR orig);
5507
5508 struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_ok(struct LDKFundingSigned o);
5509
5510 struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_err(struct LDKDecodeError e);
5511
5512 void CResult_FundingSignedDecodeErrorZ_free(struct LDKCResult_FundingSignedDecodeErrorZ _res);
5513
5514 struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_clone(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR orig);
5515
5516 struct LDKCResult_FundingLockedDecodeErrorZ CResult_FundingLockedDecodeErrorZ_ok(struct LDKFundingLocked o);
5517
5518 struct LDKCResult_FundingLockedDecodeErrorZ CResult_FundingLockedDecodeErrorZ_err(struct LDKDecodeError e);
5519
5520 void CResult_FundingLockedDecodeErrorZ_free(struct LDKCResult_FundingLockedDecodeErrorZ _res);
5521
5522 struct LDKCResult_FundingLockedDecodeErrorZ CResult_FundingLockedDecodeErrorZ_clone(const struct LDKCResult_FundingLockedDecodeErrorZ *NONNULL_PTR orig);
5523
5524 struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_ok(struct LDKInit o);
5525
5526 struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_err(struct LDKDecodeError e);
5527
5528 void CResult_InitDecodeErrorZ_free(struct LDKCResult_InitDecodeErrorZ _res);
5529
5530 struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_clone(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR orig);
5531
5532 struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_ok(struct LDKOpenChannel o);
5533
5534 struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_err(struct LDKDecodeError e);
5535
5536 void CResult_OpenChannelDecodeErrorZ_free(struct LDKCResult_OpenChannelDecodeErrorZ _res);
5537
5538 struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_clone(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR orig);
5539
5540 struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_ok(struct LDKRevokeAndACK o);
5541
5542 struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_err(struct LDKDecodeError e);
5543
5544 void CResult_RevokeAndACKDecodeErrorZ_free(struct LDKCResult_RevokeAndACKDecodeErrorZ _res);
5545
5546 struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_clone(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR orig);
5547
5548 struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_ok(struct LDKShutdown o);
5549
5550 struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_err(struct LDKDecodeError e);
5551
5552 void CResult_ShutdownDecodeErrorZ_free(struct LDKCResult_ShutdownDecodeErrorZ _res);
5553
5554 struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_clone(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR orig);
5555
5556 struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_ok(struct LDKUpdateFailHTLC o);
5557
5558 struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_err(struct LDKDecodeError e);
5559
5560 void CResult_UpdateFailHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailHTLCDecodeErrorZ _res);
5561
5562 struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR orig);
5563
5564 struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(struct LDKUpdateFailMalformedHTLC o);
5565
5566 struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(struct LDKDecodeError e);
5567
5568 void CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ _res);
5569
5570 struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR orig);
5571
5572 struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_ok(struct LDKUpdateFee o);
5573
5574 struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_err(struct LDKDecodeError e);
5575
5576 void CResult_UpdateFeeDecodeErrorZ_free(struct LDKCResult_UpdateFeeDecodeErrorZ _res);
5577
5578 struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_clone(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR orig);
5579
5580 struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_ok(struct LDKUpdateFulfillHTLC o);
5581
5582 struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_err(struct LDKDecodeError e);
5583
5584 void CResult_UpdateFulfillHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ _res);
5585
5586 struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR orig);
5587
5588 struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_ok(struct LDKUpdateAddHTLC o);
5589
5590 struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_err(struct LDKDecodeError e);
5591
5592 void CResult_UpdateAddHTLCDecodeErrorZ_free(struct LDKCResult_UpdateAddHTLCDecodeErrorZ _res);
5593
5594 struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR orig);
5595
5596 struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_ok(struct LDKPing o);
5597
5598 struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_err(struct LDKDecodeError e);
5599
5600 void CResult_PingDecodeErrorZ_free(struct LDKCResult_PingDecodeErrorZ _res);
5601
5602 struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_clone(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR orig);
5603
5604 struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_ok(struct LDKPong o);
5605
5606 struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_err(struct LDKDecodeError e);
5607
5608 void CResult_PongDecodeErrorZ_free(struct LDKCResult_PongDecodeErrorZ _res);
5609
5610 struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_clone(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR orig);
5611
5612 struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(struct LDKUnsignedChannelAnnouncement o);
5613
5614 struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
5615
5616 void CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ _res);
5617
5618 struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
5619
5620 struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_ok(struct LDKChannelAnnouncement o);
5621
5622 struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
5623
5624 void CResult_ChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_ChannelAnnouncementDecodeErrorZ _res);
5625
5626 struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
5627
5628 struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_ok(struct LDKUnsignedChannelUpdate o);
5629
5630 struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
5631
5632 void CResult_UnsignedChannelUpdateDecodeErrorZ_free(struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ _res);
5633
5634 struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
5635
5636 struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_ok(struct LDKChannelUpdate o);
5637
5638 struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
5639
5640 void CResult_ChannelUpdateDecodeErrorZ_free(struct LDKCResult_ChannelUpdateDecodeErrorZ _res);
5641
5642 struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
5643
5644 struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_ok(struct LDKErrorMessage o);
5645
5646 struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_err(struct LDKDecodeError e);
5647
5648 void CResult_ErrorMessageDecodeErrorZ_free(struct LDKCResult_ErrorMessageDecodeErrorZ _res);
5649
5650 struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_clone(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR orig);
5651
5652 struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(struct LDKUnsignedNodeAnnouncement o);
5653
5654 struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
5655
5656 void CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ _res);
5657
5658 struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
5659
5660 struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_ok(struct LDKNodeAnnouncement o);
5661
5662 struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
5663
5664 void CResult_NodeAnnouncementDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementDecodeErrorZ _res);
5665
5666 struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
5667
5668 struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_ok(struct LDKQueryShortChannelIds o);
5669
5670 struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_err(struct LDKDecodeError e);
5671
5672 void CResult_QueryShortChannelIdsDecodeErrorZ_free(struct LDKCResult_QueryShortChannelIdsDecodeErrorZ _res);
5673
5674 struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_clone(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR orig);
5675
5676 struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(struct LDKReplyShortChannelIdsEnd o);
5677
5678 struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(struct LDKDecodeError e);
5679
5680 void CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ _res);
5681
5682 struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR orig);
5683
5684 struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_ok(struct LDKQueryChannelRange o);
5685
5686 struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
5687
5688 void CResult_QueryChannelRangeDecodeErrorZ_free(struct LDKCResult_QueryChannelRangeDecodeErrorZ _res);
5689
5690 struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_clone(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR orig);
5691
5692 struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_ok(struct LDKReplyChannelRange o);
5693
5694 struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
5695
5696 void CResult_ReplyChannelRangeDecodeErrorZ_free(struct LDKCResult_ReplyChannelRangeDecodeErrorZ _res);
5697
5698 struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_clone(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR orig);
5699
5700 struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_ok(struct LDKGossipTimestampFilter o);
5701
5702 struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_err(struct LDKDecodeError e);
5703
5704 void CResult_GossipTimestampFilterDecodeErrorZ_free(struct LDKCResult_GossipTimestampFilterDecodeErrorZ _res);
5705
5706 struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_clone(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR orig);
5707
5708 /**
5709  * Frees any resources used by the Event
5710  */
5711 void Event_free(struct LDKEvent this_ptr);
5712
5713 /**
5714  * Creates a copy of the Event
5715  */
5716 struct LDKEvent Event_clone(const struct LDKEvent *NONNULL_PTR orig);
5717
5718 /**
5719  * Serialize the Event object into a byte array which can be read by Event_read
5720  */
5721 struct LDKCVec_u8Z Event_write(const struct LDKEvent *NONNULL_PTR obj);
5722
5723 /**
5724  * Frees any resources used by the MessageSendEvent
5725  */
5726 void MessageSendEvent_free(struct LDKMessageSendEvent this_ptr);
5727
5728 /**
5729  * Creates a copy of the MessageSendEvent
5730  */
5731 struct LDKMessageSendEvent MessageSendEvent_clone(const struct LDKMessageSendEvent *NONNULL_PTR orig);
5732
5733 /**
5734  * Calls the free function if one is set
5735  */
5736 void MessageSendEventsProvider_free(struct LDKMessageSendEventsProvider this_ptr);
5737
5738 /**
5739  * Calls the free function if one is set
5740  */
5741 void EventsProvider_free(struct LDKEventsProvider this_ptr);
5742
5743 /**
5744  * Frees any resources used by the APIError
5745  */
5746 void APIError_free(struct LDKAPIError this_ptr);
5747
5748 /**
5749  * Creates a copy of the APIError
5750  */
5751 struct LDKAPIError APIError_clone(const struct LDKAPIError *NONNULL_PTR orig);
5752
5753 /**
5754  * Creates a copy of the Level
5755  */
5756 enum LDKLevel Level_clone(const enum LDKLevel *NONNULL_PTR orig);
5757
5758 /**
5759  * Returns the most verbose logging level.
5760  */
5761 MUST_USE_RES enum LDKLevel Level_max(void);
5762
5763 /**
5764  * Calls the free function if one is set
5765  */
5766 void Logger_free(struct LDKLogger this_ptr);
5767
5768 /**
5769  * Frees any resources used by the ChannelHandshakeConfig, if is_owned is set and inner is non-NULL.
5770  */
5771 void ChannelHandshakeConfig_free(struct LDKChannelHandshakeConfig this_obj);
5772
5773 /**
5774  * Confirmations we will wait for before considering the channel locked in.
5775  * Applied only for inbound channels (see ChannelHandshakeLimits::max_minimum_depth for the
5776  * equivalent limit applied to outbound channels).
5777  *
5778  * Default value: 6.
5779  */
5780 uint32_t ChannelHandshakeConfig_get_minimum_depth(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
5781
5782 /**
5783  * Confirmations we will wait for before considering the channel locked in.
5784  * Applied only for inbound channels (see ChannelHandshakeLimits::max_minimum_depth for the
5785  * equivalent limit applied to outbound channels).
5786  *
5787  * Default value: 6.
5788  */
5789 void ChannelHandshakeConfig_set_minimum_depth(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint32_t val);
5790
5791 /**
5792  * Set to the number of blocks we require our counterparty to wait to claim their money (ie
5793  * the number of blocks we have to punish our counterparty if they broadcast a revoked
5794  * transaction).
5795  *
5796  * This is one of the main parameters of our security model. We (or one of our watchtowers) MUST
5797  * be online to check for revoked transactions on-chain at least once every our_to_self_delay
5798  * blocks (minus some margin to allow us enough time to broadcast and confirm a transaction,
5799  * possibly with time in between to RBF the spending transaction).
5800  *
5801  * Meanwhile, asking for a too high delay, we bother peer to freeze funds for nothing in
5802  * case of an honest unilateral channel close, which implicitly decrease the economic value of
5803  * our channel.
5804  *
5805  * Default value: [`BREAKDOWN_TIMEOUT`], we enforce it as a minimum at channel opening so you
5806  * can tweak config to ask for more security, not less.
5807  */
5808 uint16_t ChannelHandshakeConfig_get_our_to_self_delay(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
5809
5810 /**
5811  * Set to the number of blocks we require our counterparty to wait to claim their money (ie
5812  * the number of blocks we have to punish our counterparty if they broadcast a revoked
5813  * transaction).
5814  *
5815  * This is one of the main parameters of our security model. We (or one of our watchtowers) MUST
5816  * be online to check for revoked transactions on-chain at least once every our_to_self_delay
5817  * blocks (minus some margin to allow us enough time to broadcast and confirm a transaction,
5818  * possibly with time in between to RBF the spending transaction).
5819  *
5820  * Meanwhile, asking for a too high delay, we bother peer to freeze funds for nothing in
5821  * case of an honest unilateral channel close, which implicitly decrease the economic value of
5822  * our channel.
5823  *
5824  * Default value: [`BREAKDOWN_TIMEOUT`], we enforce it as a minimum at channel opening so you
5825  * can tweak config to ask for more security, not less.
5826  */
5827 void ChannelHandshakeConfig_set_our_to_self_delay(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint16_t val);
5828
5829 /**
5830  * Set to the smallest value HTLC we will accept to process.
5831  *
5832  * This value is sent to our counterparty on channel-open and we close the channel any time
5833  * our counterparty misbehaves by sending us an HTLC with a value smaller than this.
5834  *
5835  * Default value: 1. If the value is less than 1, it is ignored and set to 1, as is required
5836  * by the protocol.
5837  */
5838 uint64_t ChannelHandshakeConfig_get_our_htlc_minimum_msat(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
5839
5840 /**
5841  * Set to the smallest value HTLC we will accept to process.
5842  *
5843  * This value is sent to our counterparty on channel-open and we close the channel any time
5844  * our counterparty misbehaves by sending us an HTLC with a value smaller than this.
5845  *
5846  * Default value: 1. If the value is less than 1, it is ignored and set to 1, as is required
5847  * by the protocol.
5848  */
5849 void ChannelHandshakeConfig_set_our_htlc_minimum_msat(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint64_t val);
5850
5851 /**
5852  * Constructs a new ChannelHandshakeConfig given each field
5853  */
5854 MUST_USE_RES struct LDKChannelHandshakeConfig ChannelHandshakeConfig_new(uint32_t minimum_depth_arg, uint16_t our_to_self_delay_arg, uint64_t our_htlc_minimum_msat_arg);
5855
5856 /**
5857  * Creates a copy of the ChannelHandshakeConfig
5858  */
5859 struct LDKChannelHandshakeConfig ChannelHandshakeConfig_clone(const struct LDKChannelHandshakeConfig *NONNULL_PTR orig);
5860
5861 /**
5862  * Creates a "default" ChannelHandshakeConfig. See struct and individual field documentaiton for details on which values are used.
5863  */
5864 MUST_USE_RES struct LDKChannelHandshakeConfig ChannelHandshakeConfig_default(void);
5865
5866 /**
5867  * Frees any resources used by the ChannelHandshakeLimits, if is_owned is set and inner is non-NULL.
5868  */
5869 void ChannelHandshakeLimits_free(struct LDKChannelHandshakeLimits this_obj);
5870
5871 /**
5872  * Minimum allowed satoshis when a channel is funded, this is supplied by the sender and so
5873  * only applies to inbound channels.
5874  *
5875  * Default value: 0.
5876  */
5877 uint64_t ChannelHandshakeLimits_get_min_funding_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
5878
5879 /**
5880  * Minimum allowed satoshis when a channel is funded, this is supplied by the sender and so
5881  * only applies to inbound channels.
5882  *
5883  * Default value: 0.
5884  */
5885 void ChannelHandshakeLimits_set_min_funding_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
5886
5887 /**
5888  * The remote node sets a limit on the minimum size of HTLCs we can send to them. This allows
5889  * you to limit the maximum minimum-size they can require.
5890  *
5891  * Default value: u64::max_value.
5892  */
5893 uint64_t ChannelHandshakeLimits_get_max_htlc_minimum_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
5894
5895 /**
5896  * The remote node sets a limit on the minimum size of HTLCs we can send to them. This allows
5897  * you to limit the maximum minimum-size they can require.
5898  *
5899  * Default value: u64::max_value.
5900  */
5901 void ChannelHandshakeLimits_set_max_htlc_minimum_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
5902
5903 /**
5904  * The remote node sets a limit on the maximum value of pending HTLCs to them at any given
5905  * time to limit their funds exposure to HTLCs. This allows you to set a minimum such value.
5906  *
5907  * Default value: 0.
5908  */
5909 uint64_t ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
5910
5911 /**
5912  * The remote node sets a limit on the maximum value of pending HTLCs to them at any given
5913  * time to limit their funds exposure to HTLCs. This allows you to set a minimum such value.
5914  *
5915  * Default value: 0.
5916  */
5917 void ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
5918
5919 /**
5920  * The remote node will require we keep a certain amount in direct payment to ourselves at all
5921  * time, ensuring that we are able to be punished if we broadcast an old state. This allows to
5922  * you limit the amount which we will have to keep to ourselves (and cannot use for HTLCs).
5923  *
5924  * Default value: u64::max_value.
5925  */
5926 uint64_t ChannelHandshakeLimits_get_max_channel_reserve_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
5927
5928 /**
5929  * The remote node will require we keep a certain amount in direct payment to ourselves at all
5930  * time, ensuring that we are able to be punished if we broadcast an old state. This allows to
5931  * you limit the amount which we will have to keep to ourselves (and cannot use for HTLCs).
5932  *
5933  * Default value: u64::max_value.
5934  */
5935 void ChannelHandshakeLimits_set_max_channel_reserve_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
5936
5937 /**
5938  * The remote node sets a limit on the maximum number of pending HTLCs to them at any given
5939  * time. This allows you to set a minimum such value.
5940  *
5941  * Default value: 0.
5942  */
5943 uint16_t ChannelHandshakeLimits_get_min_max_accepted_htlcs(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
5944
5945 /**
5946  * The remote node sets a limit on the maximum number of pending HTLCs to them at any given
5947  * time. This allows you to set a minimum such value.
5948  *
5949  * Default value: 0.
5950  */
5951 void ChannelHandshakeLimits_set_min_max_accepted_htlcs(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
5952
5953 /**
5954  * Outputs below a certain value will not be added to on-chain transactions. The dust value is
5955  * required to always be higher than this value so this only applies to HTLC outputs (and
5956  * potentially to-self outputs before any payments have been made).
5957  * Thus, HTLCs below this amount plus HTLC transaction fees are not enforceable on-chain.
5958  * This setting allows you to set a minimum dust limit for their commitment transactions,
5959  * reflecting the reality that tiny outputs are not considered standard transactions and will
5960  * not propagate through the Bitcoin network.
5961  *
5962  * Default value: 546, the current dust limit on the Bitcoin network.
5963  */
5964 uint64_t ChannelHandshakeLimits_get_min_dust_limit_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
5965
5966 /**
5967  * Outputs below a certain value will not be added to on-chain transactions. The dust value is
5968  * required to always be higher than this value so this only applies to HTLC outputs (and
5969  * potentially to-self outputs before any payments have been made).
5970  * Thus, HTLCs below this amount plus HTLC transaction fees are not enforceable on-chain.
5971  * This setting allows you to set a minimum dust limit for their commitment transactions,
5972  * reflecting the reality that tiny outputs are not considered standard transactions and will
5973  * not propagate through the Bitcoin network.
5974  *
5975  * Default value: 546, the current dust limit on the Bitcoin network.
5976  */
5977 void ChannelHandshakeLimits_set_min_dust_limit_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
5978
5979 /**
5980  * Maximum allowed threshold above which outputs will not be generated in their commitment
5981  * transactions.
5982  * HTLCs below this amount plus HTLC transaction fees are not enforceable on-chain.
5983  *
5984  * Default value: u64::max_value.
5985  */
5986 uint64_t ChannelHandshakeLimits_get_max_dust_limit_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
5987
5988 /**
5989  * Maximum allowed threshold above which outputs will not be generated in their commitment
5990  * transactions.
5991  * HTLCs below this amount plus HTLC transaction fees are not enforceable on-chain.
5992  *
5993  * Default value: u64::max_value.
5994  */
5995 void ChannelHandshakeLimits_set_max_dust_limit_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
5996
5997 /**
5998  * Before a channel is usable the funding transaction will need to be confirmed by at least a
5999  * certain number of blocks, specified by the node which is not the funder (as the funder can
6000  * assume they aren't going to double-spend themselves).
6001  * This config allows you to set a limit on the maximum amount of time to wait.
6002  *
6003  * Default value: 144, or roughly one day and only applies to outbound channels.
6004  */
6005 uint32_t ChannelHandshakeLimits_get_max_minimum_depth(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
6006
6007 /**
6008  * Before a channel is usable the funding transaction will need to be confirmed by at least a
6009  * certain number of blocks, specified by the node which is not the funder (as the funder can
6010  * assume they aren't going to double-spend themselves).
6011  * This config allows you to set a limit on the maximum amount of time to wait.
6012  *
6013  * Default value: 144, or roughly one day and only applies to outbound channels.
6014  */
6015 void ChannelHandshakeLimits_set_max_minimum_depth(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint32_t val);
6016
6017 /**
6018  * Set to force the incoming channel to match our announced channel preference in
6019  * ChannelConfig.
6020  *
6021  * Default value: true, to make the default that no announced channels are possible (which is
6022  * appropriate for any nodes which are not online very reliably).
6023  */
6024 bool ChannelHandshakeLimits_get_force_announced_channel_preference(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
6025
6026 /**
6027  * Set to force the incoming channel to match our announced channel preference in
6028  * ChannelConfig.
6029  *
6030  * Default value: true, to make the default that no announced channels are possible (which is
6031  * appropriate for any nodes which are not online very reliably).
6032  */
6033 void ChannelHandshakeLimits_set_force_announced_channel_preference(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, bool val);
6034
6035 /**
6036  * Set to the amount of time we're willing to wait to claim money back to us.
6037  *
6038  * Not checking this value would be a security issue, as our peer would be able to set it to
6039  * max relative lock-time (a year) and we would \"lose\" money as it would be locked for a long time.
6040  *
6041  * Default value: 2016, which we also enforce as a maximum value so you can tweak config to
6042  * reduce the loss of having useless locked funds (if your peer accepts)
6043  */
6044 uint16_t ChannelHandshakeLimits_get_their_to_self_delay(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
6045
6046 /**
6047  * Set to the amount of time we're willing to wait to claim money back to us.
6048  *
6049  * Not checking this value would be a security issue, as our peer would be able to set it to
6050  * max relative lock-time (a year) and we would \"lose\" money as it would be locked for a long time.
6051  *
6052  * Default value: 2016, which we also enforce as a maximum value so you can tweak config to
6053  * reduce the loss of having useless locked funds (if your peer accepts)
6054  */
6055 void ChannelHandshakeLimits_set_their_to_self_delay(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
6056
6057 /**
6058  * Constructs a new ChannelHandshakeLimits given each field
6059  */
6060 MUST_USE_RES struct 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);
6061
6062 /**
6063  * Creates a copy of the ChannelHandshakeLimits
6064  */
6065 struct LDKChannelHandshakeLimits ChannelHandshakeLimits_clone(const struct LDKChannelHandshakeLimits *NONNULL_PTR orig);
6066
6067 /**
6068  * Creates a "default" ChannelHandshakeLimits. See struct and individual field documentaiton for details on which values are used.
6069  */
6070 MUST_USE_RES struct LDKChannelHandshakeLimits ChannelHandshakeLimits_default(void);
6071
6072 /**
6073  * Frees any resources used by the ChannelConfig, if is_owned is set and inner is non-NULL.
6074  */
6075 void ChannelConfig_free(struct LDKChannelConfig this_obj);
6076
6077 /**
6078  * Amount (in millionths of a satoshi) the channel will charge per transferred satoshi.
6079  * This may be allowed to change at runtime in a later update, however doing so must result in
6080  * update messages sent to notify all nodes of our updated relay fee.
6081  *
6082  * Default value: 0.
6083  */
6084 uint32_t ChannelConfig_get_fee_proportional_millionths(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
6085
6086 /**
6087  * Amount (in millionths of a satoshi) the channel will charge per transferred satoshi.
6088  * This may be allowed to change at runtime in a later update, however doing so must result in
6089  * update messages sent to notify all nodes of our updated relay fee.
6090  *
6091  * Default value: 0.
6092  */
6093 void ChannelConfig_set_fee_proportional_millionths(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
6094
6095 /**
6096  * The difference in the CLTV value between incoming HTLCs and an outbound HTLC forwarded over
6097  * the channel this config applies to.
6098  *
6099  * This is analogous to [`ChannelHandshakeConfig::our_to_self_delay`] but applies to in-flight
6100  * HTLC balance when a channel appears on-chain whereas
6101  * [`ChannelHandshakeConfig::our_to_self_delay`] applies to the remaining
6102  * (non-HTLC-encumbered) balance.
6103  *
6104  * Thus, for HTLC-encumbered balances to be enforced on-chain when a channel is force-closed,
6105  * we (or one of our watchtowers) MUST be online to check for broadcast of the current
6106  * commitment transaction at least once per this many blocks (minus some margin to allow us
6107  * enough time to broadcast and confirm a transaction, possibly with time in between to RBF
6108  * the spending transaction).
6109  *
6110  * Default value: 72 (12 hours at an average of 6 blocks/hour).
6111  * Minimum value: [`MIN_CLTV_EXPIRY_DELTA`], any values less than this will be treated as
6112  *                [`MIN_CLTV_EXPIRY_DELTA`] instead.
6113  *
6114  * [`MIN_CLTV_EXPIRY_DELTA`]: crate::ln::channelmanager::MIN_CLTV_EXPIRY_DELTA
6115  */
6116 uint16_t ChannelConfig_get_cltv_expiry_delta(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
6117
6118 /**
6119  * The difference in the CLTV value between incoming HTLCs and an outbound HTLC forwarded over
6120  * the channel this config applies to.
6121  *
6122  * This is analogous to [`ChannelHandshakeConfig::our_to_self_delay`] but applies to in-flight
6123  * HTLC balance when a channel appears on-chain whereas
6124  * [`ChannelHandshakeConfig::our_to_self_delay`] applies to the remaining
6125  * (non-HTLC-encumbered) balance.
6126  *
6127  * Thus, for HTLC-encumbered balances to be enforced on-chain when a channel is force-closed,
6128  * we (or one of our watchtowers) MUST be online to check for broadcast of the current
6129  * commitment transaction at least once per this many blocks (minus some margin to allow us
6130  * enough time to broadcast and confirm a transaction, possibly with time in between to RBF
6131  * the spending transaction).
6132  *
6133  * Default value: 72 (12 hours at an average of 6 blocks/hour).
6134  * Minimum value: [`MIN_CLTV_EXPIRY_DELTA`], any values less than this will be treated as
6135  *                [`MIN_CLTV_EXPIRY_DELTA`] instead.
6136  *
6137  * [`MIN_CLTV_EXPIRY_DELTA`]: crate::ln::channelmanager::MIN_CLTV_EXPIRY_DELTA
6138  */
6139 void ChannelConfig_set_cltv_expiry_delta(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint16_t val);
6140
6141 /**
6142  * Set to announce the channel publicly and notify all nodes that they can route via this
6143  * channel.
6144  *
6145  * This should only be set to true for nodes which expect to be online reliably.
6146  *
6147  * As the node which funds a channel picks this value this will only apply for new outbound
6148  * channels unless ChannelHandshakeLimits::force_announced_channel_preferences is set.
6149  *
6150  * This cannot be changed after the initial channel handshake.
6151  *
6152  * Default value: false.
6153  */
6154 bool ChannelConfig_get_announced_channel(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
6155
6156 /**
6157  * Set to announce the channel publicly and notify all nodes that they can route via this
6158  * channel.
6159  *
6160  * This should only be set to true for nodes which expect to be online reliably.
6161  *
6162  * As the node which funds a channel picks this value this will only apply for new outbound
6163  * channels unless ChannelHandshakeLimits::force_announced_channel_preferences is set.
6164  *
6165  * This cannot be changed after the initial channel handshake.
6166  *
6167  * Default value: false.
6168  */
6169 void ChannelConfig_set_announced_channel(struct LDKChannelConfig *NONNULL_PTR this_ptr, bool val);
6170
6171 /**
6172  * When set, we commit to an upfront shutdown_pubkey at channel open. If our counterparty
6173  * supports it, they will then enforce the mutual-close output to us matches what we provided
6174  * at intialization, preventing us from closing to an alternate pubkey.
6175  *
6176  * This is set to true by default to provide a slight increase in security, though ultimately
6177  * any attacker who is able to take control of a channel can just as easily send the funds via
6178  * lightning payments, so we never require that our counterparties support this option.
6179  *
6180  * This cannot be changed after a channel has been initialized.
6181  *
6182  * Default value: true.
6183  */
6184 bool ChannelConfig_get_commit_upfront_shutdown_pubkey(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
6185
6186 /**
6187  * When set, we commit to an upfront shutdown_pubkey at channel open. If our counterparty
6188  * supports it, they will then enforce the mutual-close output to us matches what we provided
6189  * at intialization, preventing us from closing to an alternate pubkey.
6190  *
6191  * This is set to true by default to provide a slight increase in security, though ultimately
6192  * any attacker who is able to take control of a channel can just as easily send the funds via
6193  * lightning payments, so we never require that our counterparties support this option.
6194  *
6195  * This cannot be changed after a channel has been initialized.
6196  *
6197  * Default value: true.
6198  */
6199 void ChannelConfig_set_commit_upfront_shutdown_pubkey(struct LDKChannelConfig *NONNULL_PTR this_ptr, bool val);
6200
6201 /**
6202  * Constructs a new ChannelConfig given each field
6203  */
6204 MUST_USE_RES struct LDKChannelConfig ChannelConfig_new(uint32_t fee_proportional_millionths_arg, uint16_t cltv_expiry_delta_arg, bool announced_channel_arg, bool commit_upfront_shutdown_pubkey_arg);
6205
6206 /**
6207  * Creates a copy of the ChannelConfig
6208  */
6209 struct LDKChannelConfig ChannelConfig_clone(const struct LDKChannelConfig *NONNULL_PTR orig);
6210
6211 /**
6212  * Creates a "default" ChannelConfig. See struct and individual field documentaiton for details on which values are used.
6213  */
6214 MUST_USE_RES struct LDKChannelConfig ChannelConfig_default(void);
6215
6216 /**
6217  * Serialize the ChannelConfig object into a byte array which can be read by ChannelConfig_read
6218  */
6219 struct LDKCVec_u8Z ChannelConfig_write(const struct LDKChannelConfig *NONNULL_PTR obj);
6220
6221 /**
6222  * Read a ChannelConfig from a byte array, created by ChannelConfig_write
6223  */
6224 struct LDKCResult_ChannelConfigDecodeErrorZ ChannelConfig_read(struct LDKu8slice ser);
6225
6226 /**
6227  * Frees any resources used by the UserConfig, if is_owned is set and inner is non-NULL.
6228  */
6229 void UserConfig_free(struct LDKUserConfig this_obj);
6230
6231 /**
6232  * Channel config that we propose to our counterparty.
6233  */
6234 struct LDKChannelHandshakeConfig UserConfig_get_own_channel_config(const struct LDKUserConfig *NONNULL_PTR this_ptr);
6235
6236 /**
6237  * Channel config that we propose to our counterparty.
6238  */
6239 void UserConfig_set_own_channel_config(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeConfig val);
6240
6241 /**
6242  * Limits applied to our counterparty's proposed channel config settings.
6243  */
6244 struct LDKChannelHandshakeLimits UserConfig_get_peer_channel_config_limits(const struct LDKUserConfig *NONNULL_PTR this_ptr);
6245
6246 /**
6247  * Limits applied to our counterparty's proposed channel config settings.
6248  */
6249 void UserConfig_set_peer_channel_config_limits(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeLimits val);
6250
6251 /**
6252  * Channel config which affects behavior during channel lifetime.
6253  */
6254 struct LDKChannelConfig UserConfig_get_channel_options(const struct LDKUserConfig *NONNULL_PTR this_ptr);
6255
6256 /**
6257  * Channel config which affects behavior during channel lifetime.
6258  */
6259 void UserConfig_set_channel_options(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelConfig val);
6260
6261 /**
6262  * Constructs a new UserConfig given each field
6263  */
6264 MUST_USE_RES struct LDKUserConfig UserConfig_new(struct LDKChannelHandshakeConfig own_channel_config_arg, struct LDKChannelHandshakeLimits peer_channel_config_limits_arg, struct LDKChannelConfig channel_options_arg);
6265
6266 /**
6267  * Creates a copy of the UserConfig
6268  */
6269 struct LDKUserConfig UserConfig_clone(const struct LDKUserConfig *NONNULL_PTR orig);
6270
6271 /**
6272  * Creates a "default" UserConfig. See struct and individual field documentaiton for details on which values are used.
6273  */
6274 MUST_USE_RES struct LDKUserConfig UserConfig_default(void);
6275
6276 /**
6277  * Creates a copy of the AccessError
6278  */
6279 enum LDKAccessError AccessError_clone(const enum LDKAccessError *NONNULL_PTR orig);
6280
6281 /**
6282  * Calls the free function if one is set
6283  */
6284 void Access_free(struct LDKAccess this_ptr);
6285
6286 /**
6287  * Calls the free function if one is set
6288  */
6289 void Listen_free(struct LDKListen this_ptr);
6290
6291 /**
6292  * Calls the free function if one is set
6293  */
6294 void Watch_free(struct LDKWatch this_ptr);
6295
6296 /**
6297  * Calls the free function if one is set
6298  */
6299 void Filter_free(struct LDKFilter this_ptr);
6300
6301 /**
6302  * Calls the free function if one is set
6303  */
6304 void BroadcasterInterface_free(struct LDKBroadcasterInterface this_ptr);
6305
6306 /**
6307  * Creates a copy of the ConfirmationTarget
6308  */
6309 enum LDKConfirmationTarget ConfirmationTarget_clone(const enum LDKConfirmationTarget *NONNULL_PTR orig);
6310
6311 /**
6312  * Calls the free function if one is set
6313  */
6314 void FeeEstimator_free(struct LDKFeeEstimator this_ptr);
6315
6316 /**
6317  * Frees any resources used by the ChainMonitor, if is_owned is set and inner is non-NULL.
6318  */
6319 void ChainMonitor_free(struct LDKChainMonitor this_obj);
6320
6321 /**
6322  * Dispatches to per-channel monitors, which are responsible for updating their on-chain view
6323  * of a channel and reacting accordingly based on transactions in the connected block. See
6324  * [`ChannelMonitor::block_connected`] for details. Any HTLCs that were resolved on chain will
6325  * be returned by [`chain::Watch::release_pending_monitor_events`].
6326  *
6327  * Calls back to [`chain::Filter`] if any monitor indicated new outputs to watch. Subsequent
6328  * calls must not exclude any transactions matching the new outputs nor any in-block
6329  * descendants of such transactions. It is not necessary to re-fetch the block to obtain
6330  * updated `txdata`.
6331  */
6332 void ChainMonitor_block_connected(const struct LDKChainMonitor *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height);
6333
6334 /**
6335  * Dispatches to per-channel monitors, which are responsible for updating their on-chain view
6336  * of a channel based on the disconnected block. See [`ChannelMonitor::block_disconnected`] for
6337  * details.
6338  */
6339 void ChainMonitor_block_disconnected(const struct LDKChainMonitor *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t disconnected_height);
6340
6341 /**
6342  * Creates a new `ChainMonitor` used to watch on-chain activity pertaining to channels.
6343  *
6344  * When an optional chain source implementing [`chain::Filter`] is provided, the chain monitor
6345  * will call back to it indicating transactions and outputs of interest. This allows clients to
6346  * pre-filter blocks or only fetch blocks matching a compact filter. Otherwise, clients may
6347  * always need to fetch full blocks absent another means for determining which blocks contain
6348  * transactions relevant to the watched channels.
6349  */
6350 MUST_USE_RES struct LDKChainMonitor ChainMonitor_new(struct LDKFilter *chain_source, struct LDKBroadcasterInterface broadcaster, struct LDKLogger logger, struct LDKFeeEstimator feeest, struct LDKPersist persister);
6351
6352 /**
6353  * Constructs a new Watch which calls the relevant methods on this_arg.
6354  * This copies the `inner` pointer in this_arg and thus the returned Watch must be freed before this_arg is
6355  */
6356 struct LDKWatch ChainMonitor_as_Watch(const struct LDKChainMonitor *NONNULL_PTR this_arg);
6357
6358 /**
6359  * Constructs a new EventsProvider which calls the relevant methods on this_arg.
6360  * This copies the `inner` pointer in this_arg and thus the returned EventsProvider must be freed before this_arg is
6361  */
6362 struct LDKEventsProvider ChainMonitor_as_EventsProvider(const struct LDKChainMonitor *NONNULL_PTR this_arg);
6363
6364 /**
6365  * Frees any resources used by the ChannelMonitorUpdate, if is_owned is set and inner is non-NULL.
6366  */
6367 void ChannelMonitorUpdate_free(struct LDKChannelMonitorUpdate this_obj);
6368
6369 /**
6370  * The sequence number of this update. Updates *must* be replayed in-order according to this
6371  * sequence number (and updates may panic if they are not). The update_id values are strictly
6372  * increasing and increase by one for each new update, with one exception specified below.
6373  *
6374  * This sequence number is also used to track up to which points updates which returned
6375  * ChannelMonitorUpdateErr::TemporaryFailure have been applied to all copies of a given
6376  * ChannelMonitor when ChannelManager::channel_monitor_updated is called.
6377  *
6378  * The only instance where update_id values are not strictly increasing is the case where we
6379  * allow post-force-close updates with a special update ID of [`CLOSED_CHANNEL_UPDATE_ID`]. See
6380  * its docs for more details.
6381  */
6382 uint64_t ChannelMonitorUpdate_get_update_id(const struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr);
6383
6384 /**
6385  * The sequence number of this update. Updates *must* be replayed in-order according to this
6386  * sequence number (and updates may panic if they are not). The update_id values are strictly
6387  * increasing and increase by one for each new update, with one exception specified below.
6388  *
6389  * This sequence number is also used to track up to which points updates which returned
6390  * ChannelMonitorUpdateErr::TemporaryFailure have been applied to all copies of a given
6391  * ChannelMonitor when ChannelManager::channel_monitor_updated is called.
6392  *
6393  * The only instance where update_id values are not strictly increasing is the case where we
6394  * allow post-force-close updates with a special update ID of [`CLOSED_CHANNEL_UPDATE_ID`]. See
6395  * its docs for more details.
6396  */
6397 void ChannelMonitorUpdate_set_update_id(struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr, uint64_t val);
6398
6399 /**
6400  * Creates a copy of the ChannelMonitorUpdate
6401  */
6402 struct LDKChannelMonitorUpdate ChannelMonitorUpdate_clone(const struct LDKChannelMonitorUpdate *NONNULL_PTR orig);
6403
6404 /**
6405  * Serialize the ChannelMonitorUpdate object into a byte array which can be read by ChannelMonitorUpdate_read
6406  */
6407 struct LDKCVec_u8Z ChannelMonitorUpdate_write(const struct LDKChannelMonitorUpdate *NONNULL_PTR obj);
6408
6409 /**
6410  * Read a ChannelMonitorUpdate from a byte array, created by ChannelMonitorUpdate_write
6411  */
6412 struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ ChannelMonitorUpdate_read(struct LDKu8slice ser);
6413
6414 /**
6415  * Creates a copy of the ChannelMonitorUpdateErr
6416  */
6417 enum LDKChannelMonitorUpdateErr ChannelMonitorUpdateErr_clone(const enum LDKChannelMonitorUpdateErr *NONNULL_PTR orig);
6418
6419 /**
6420  * Frees any resources used by the MonitorUpdateError, if is_owned is set and inner is non-NULL.
6421  */
6422 void MonitorUpdateError_free(struct LDKMonitorUpdateError this_obj);
6423
6424 /**
6425  * Creates a copy of the MonitorUpdateError
6426  */
6427 struct LDKMonitorUpdateError MonitorUpdateError_clone(const struct LDKMonitorUpdateError *NONNULL_PTR orig);
6428
6429 /**
6430  * Frees any resources used by the MonitorEvent
6431  */
6432 void MonitorEvent_free(struct LDKMonitorEvent this_ptr);
6433
6434 /**
6435  * Creates a copy of the MonitorEvent
6436  */
6437 struct LDKMonitorEvent MonitorEvent_clone(const struct LDKMonitorEvent *NONNULL_PTR orig);
6438
6439 /**
6440  * Frees any resources used by the HTLCUpdate, if is_owned is set and inner is non-NULL.
6441  */
6442 void HTLCUpdate_free(struct LDKHTLCUpdate this_obj);
6443
6444 /**
6445  * Creates a copy of the HTLCUpdate
6446  */
6447 struct LDKHTLCUpdate HTLCUpdate_clone(const struct LDKHTLCUpdate *NONNULL_PTR orig);
6448
6449 /**
6450  * Serialize the HTLCUpdate object into a byte array which can be read by HTLCUpdate_read
6451  */
6452 struct LDKCVec_u8Z HTLCUpdate_write(const struct LDKHTLCUpdate *NONNULL_PTR obj);
6453
6454 /**
6455  * Read a HTLCUpdate from a byte array, created by HTLCUpdate_write
6456  */
6457 struct LDKCResult_HTLCUpdateDecodeErrorZ HTLCUpdate_read(struct LDKu8slice ser);
6458
6459 /**
6460  * Frees any resources used by the ChannelMonitor, if is_owned is set and inner is non-NULL.
6461  */
6462 void ChannelMonitor_free(struct LDKChannelMonitor this_obj);
6463
6464 /**
6465  * Serialize the ChannelMonitor object into a byte array which can be read by ChannelMonitor_read
6466  */
6467 struct LDKCVec_u8Z ChannelMonitor_write(const struct LDKChannelMonitor *NONNULL_PTR obj);
6468
6469 /**
6470  * Updates a ChannelMonitor on the basis of some new information provided by the Channel
6471  * itself.
6472  *
6473  * panics if the given update is not the next update by update_id.
6474  */
6475 MUST_USE_RES struct LDKCResult_NoneMonitorUpdateErrorZ ChannelMonitor_update_monitor(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKChannelMonitorUpdate *NONNULL_PTR updates, const struct LDKBroadcasterInterface *NONNULL_PTR broadcaster, const struct LDKFeeEstimator *NONNULL_PTR fee_estimator, const struct LDKLogger *NONNULL_PTR logger);
6476
6477 /**
6478  * Gets the update_id from the latest ChannelMonitorUpdate which was applied to this
6479  * ChannelMonitor.
6480  */
6481 MUST_USE_RES uint64_t ChannelMonitor_get_latest_update_id(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
6482
6483 /**
6484  * Gets the funding transaction outpoint of the channel this ChannelMonitor is monitoring for.
6485  */
6486 MUST_USE_RES struct LDKC2Tuple_OutPointScriptZ ChannelMonitor_get_funding_txo(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
6487
6488 /**
6489  * Gets a list of txids, with their output scripts (in the order they appear in the
6490  * transaction), which we must learn about spends of via block_connected().
6491  */
6492 MUST_USE_RES struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ ChannelMonitor_get_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
6493
6494 /**
6495  * Loads the funding txo and outputs to watch into the given `chain::Filter` by repeatedly
6496  * calling `chain::Filter::register_output` and `chain::Filter::register_tx` until all outputs
6497  * have been registered.
6498  */
6499 void ChannelMonitor_load_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKFilter *NONNULL_PTR filter);
6500
6501 /**
6502  * Get the list of HTLCs who's status has been updated on chain. This should be called by
6503  * ChannelManager via [`chain::Watch::release_pending_monitor_events`].
6504  */
6505 MUST_USE_RES struct LDKCVec_MonitorEventZ ChannelMonitor_get_and_clear_pending_monitor_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
6506
6507 /**
6508  * Gets the list of pending events which were generated by previous actions, clearing the list
6509  * in the process.
6510  *
6511  * This is called by ChainMonitor::get_and_clear_pending_events() and is equivalent to
6512  * EventsProvider::get_and_clear_pending_events() except that it requires &mut self as we do
6513  * no internal locking in ChannelMonitors.
6514  */
6515 MUST_USE_RES struct LDKCVec_EventZ ChannelMonitor_get_and_clear_pending_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
6516
6517 /**
6518  * Used by ChannelManager deserialization to broadcast the latest holder state if its copy of
6519  * the Channel was out-of-date. You may use it to get a broadcastable holder toxic tx in case of
6520  * fallen-behind, i.e when receiving a channel_reestablish with a proof that our counterparty side knows
6521  * a higher revocation secret than the holder commitment number we are aware of. Broadcasting these
6522  * transactions are UNSAFE, as they allow counterparty side to punish you. Nevertheless you may want to
6523  * broadcast them if counterparty don't close channel with his higher commitment transaction after a
6524  * substantial amount of time (a month or even a year) to get back funds. Best may be to contact
6525  * out-of-band the other node operator to coordinate with him if option is available to you.
6526  * In any-case, choice is up to the user.
6527  */
6528 MUST_USE_RES struct LDKCVec_TransactionZ ChannelMonitor_get_latest_holder_commitment_txn(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKLogger *NONNULL_PTR logger);
6529
6530 /**
6531  * Processes transactions in a newly connected block, which may result in any of the following:
6532  * - update the monitor's state against resolved HTLCs
6533  * - punish the counterparty in the case of seeing a revoked commitment transaction
6534  * - force close the channel and claim/timeout incoming/outgoing HTLCs if near expiration
6535  * - detect settled outputs for later spending
6536  * - schedule and bump any in-flight claims
6537  *
6538  * Returns any new outputs to watch from `txdata`; after called, these are also included in
6539  * [`get_outputs_to_watch`].
6540  *
6541  * [`get_outputs_to_watch`]: #method.get_outputs_to_watch
6542  */
6543 MUST_USE_RES struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ ChannelMonitor_block_connected(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height, struct LDKBroadcasterInterface broadcaster, struct LDKFeeEstimator fee_estimator, struct LDKLogger logger);
6544
6545 /**
6546  * Determines if the disconnected block contained any transactions of interest and updates
6547  * appropriately.
6548  */
6549 void ChannelMonitor_block_disconnected(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height, struct LDKBroadcasterInterface broadcaster, struct LDKFeeEstimator fee_estimator, struct LDKLogger logger);
6550
6551 /**
6552  * Calls the free function if one is set
6553  */
6554 void Persist_free(struct LDKPersist this_ptr);
6555
6556 /**
6557  * Read a C2Tuple_BlockHashChannelMonitorZ from a byte array, created by C2Tuple_BlockHashChannelMonitorZ_write
6558  */
6559 struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ C2Tuple_BlockHashChannelMonitorZ_read(struct LDKu8slice ser, const struct LDKKeysInterface *NONNULL_PTR arg);
6560
6561 /**
6562  * Frees any resources used by the OutPoint, if is_owned is set and inner is non-NULL.
6563  */
6564 void OutPoint_free(struct LDKOutPoint this_obj);
6565
6566 /**
6567  * The referenced transaction's txid.
6568  */
6569 const uint8_t (*OutPoint_get_txid(const struct LDKOutPoint *NONNULL_PTR this_ptr))[32];
6570
6571 /**
6572  * The referenced transaction's txid.
6573  */
6574 void OutPoint_set_txid(struct LDKOutPoint *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
6575
6576 /**
6577  * The index of the referenced output in its transaction's vout.
6578  */
6579 uint16_t OutPoint_get_index(const struct LDKOutPoint *NONNULL_PTR this_ptr);
6580
6581 /**
6582  * The index of the referenced output in its transaction's vout.
6583  */
6584 void OutPoint_set_index(struct LDKOutPoint *NONNULL_PTR this_ptr, uint16_t val);
6585
6586 /**
6587  * Constructs a new OutPoint given each field
6588  */
6589 MUST_USE_RES struct LDKOutPoint OutPoint_new(struct LDKThirtyTwoBytes txid_arg, uint16_t index_arg);
6590
6591 /**
6592  * Creates a copy of the OutPoint
6593  */
6594 struct LDKOutPoint OutPoint_clone(const struct LDKOutPoint *NONNULL_PTR orig);
6595
6596 /**
6597  * Convert an `OutPoint` to a lightning channel id.
6598  */
6599 MUST_USE_RES struct LDKThirtyTwoBytes OutPoint_to_channel_id(const struct LDKOutPoint *NONNULL_PTR this_arg);
6600
6601 /**
6602  * Serialize the OutPoint object into a byte array which can be read by OutPoint_read
6603  */
6604 struct LDKCVec_u8Z OutPoint_write(const struct LDKOutPoint *NONNULL_PTR obj);
6605
6606 /**
6607  * Read a OutPoint from a byte array, created by OutPoint_write
6608  */
6609 struct LDKCResult_OutPointDecodeErrorZ OutPoint_read(struct LDKu8slice ser);
6610
6611 /**
6612  * Frees any resources used by the DelayedPaymentOutputDescriptor, if is_owned is set and inner is non-NULL.
6613  */
6614 void DelayedPaymentOutputDescriptor_free(struct LDKDelayedPaymentOutputDescriptor this_obj);
6615
6616 /**
6617  * The outpoint which is spendable
6618  */
6619 struct LDKOutPoint DelayedPaymentOutputDescriptor_get_outpoint(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
6620
6621 /**
6622  * The outpoint which is spendable
6623  */
6624 void DelayedPaymentOutputDescriptor_set_outpoint(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
6625
6626 /**
6627  * Per commitment point to derive delayed_payment_key by key holder
6628  */
6629 struct LDKPublicKey DelayedPaymentOutputDescriptor_get_per_commitment_point(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
6630
6631 /**
6632  * Per commitment point to derive delayed_payment_key by key holder
6633  */
6634 void DelayedPaymentOutputDescriptor_set_per_commitment_point(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
6635
6636 /**
6637  * The nSequence value which must be set in the spending input to satisfy the OP_CSV in
6638  * the witness_script.
6639  */
6640 uint16_t DelayedPaymentOutputDescriptor_get_to_self_delay(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
6641
6642 /**
6643  * The nSequence value which must be set in the spending input to satisfy the OP_CSV in
6644  * the witness_script.
6645  */
6646 void DelayedPaymentOutputDescriptor_set_to_self_delay(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint16_t val);
6647
6648 /**
6649  * The output which is referenced by the given outpoint
6650  */
6651 void DelayedPaymentOutputDescriptor_set_output(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
6652
6653 /**
6654  * The revocation point specific to the commitment transaction which was broadcast. Used to
6655  * derive the witnessScript for this output.
6656  */
6657 struct LDKPublicKey DelayedPaymentOutputDescriptor_get_revocation_pubkey(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
6658
6659 /**
6660  * The revocation point specific to the commitment transaction which was broadcast. Used to
6661  * derive the witnessScript for this output.
6662  */
6663 void DelayedPaymentOutputDescriptor_set_revocation_pubkey(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
6664
6665 /**
6666  * Arbitrary identification information returned by a call to
6667  * `Sign::channel_keys_id()`. This may be useful in re-deriving keys used in
6668  * the channel to spend the output.
6669  */
6670 const uint8_t (*DelayedPaymentOutputDescriptor_get_channel_keys_id(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
6671
6672 /**
6673  * Arbitrary identification information returned by a call to
6674  * `Sign::channel_keys_id()`. This may be useful in re-deriving keys used in
6675  * the channel to spend the output.
6676  */
6677 void DelayedPaymentOutputDescriptor_set_channel_keys_id(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
6678
6679 /**
6680  * The value of the channel which this output originated from, possibly indirectly.
6681  */
6682 uint64_t DelayedPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
6683
6684 /**
6685  * The value of the channel which this output originated from, possibly indirectly.
6686  */
6687 void DelayedPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
6688
6689 /**
6690  * Constructs a new DelayedPaymentOutputDescriptor given each field
6691  */
6692 MUST_USE_RES struct LDKDelayedPaymentOutputDescriptor DelayedPaymentOutputDescriptor_new(struct LDKOutPoint outpoint_arg, struct LDKPublicKey per_commitment_point_arg, uint16_t to_self_delay_arg, struct LDKTxOut output_arg, struct LDKPublicKey revocation_pubkey_arg, struct LDKThirtyTwoBytes channel_keys_id_arg, uint64_t channel_value_satoshis_arg);
6693
6694 /**
6695  * Creates a copy of the DelayedPaymentOutputDescriptor
6696  */
6697 struct LDKDelayedPaymentOutputDescriptor DelayedPaymentOutputDescriptor_clone(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR orig);
6698
6699 /**
6700  * Frees any resources used by the StaticPaymentOutputDescriptor, if is_owned is set and inner is non-NULL.
6701  */
6702 void StaticPaymentOutputDescriptor_free(struct LDKStaticPaymentOutputDescriptor this_obj);
6703
6704 /**
6705  * The outpoint which is spendable
6706  */
6707 struct LDKOutPoint StaticPaymentOutputDescriptor_get_outpoint(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
6708
6709 /**
6710  * The outpoint which is spendable
6711  */
6712 void StaticPaymentOutputDescriptor_set_outpoint(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
6713
6714 /**
6715  * The output which is referenced by the given outpoint
6716  */
6717 void StaticPaymentOutputDescriptor_set_output(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
6718
6719 /**
6720  * Arbitrary identification information returned by a call to
6721  * `Sign::channel_keys_id()`. This may be useful in re-deriving keys used in
6722  * the channel to spend the output.
6723  */
6724 const uint8_t (*StaticPaymentOutputDescriptor_get_channel_keys_id(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
6725
6726 /**
6727  * Arbitrary identification information returned by a call to
6728  * `Sign::channel_keys_id()`. This may be useful in re-deriving keys used in
6729  * the channel to spend the output.
6730  */
6731 void StaticPaymentOutputDescriptor_set_channel_keys_id(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
6732
6733 /**
6734  * The value of the channel which this transactions spends.
6735  */
6736 uint64_t StaticPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
6737
6738 /**
6739  * The value of the channel which this transactions spends.
6740  */
6741 void StaticPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
6742
6743 /**
6744  * Constructs a new StaticPaymentOutputDescriptor given each field
6745  */
6746 MUST_USE_RES struct LDKStaticPaymentOutputDescriptor StaticPaymentOutputDescriptor_new(struct LDKOutPoint outpoint_arg, struct LDKTxOut output_arg, struct LDKThirtyTwoBytes channel_keys_id_arg, uint64_t channel_value_satoshis_arg);
6747
6748 /**
6749  * Creates a copy of the StaticPaymentOutputDescriptor
6750  */
6751 struct LDKStaticPaymentOutputDescriptor StaticPaymentOutputDescriptor_clone(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR orig);
6752
6753 /**
6754  * Frees any resources used by the SpendableOutputDescriptor
6755  */
6756 void SpendableOutputDescriptor_free(struct LDKSpendableOutputDescriptor this_ptr);
6757
6758 /**
6759  * Creates a copy of the SpendableOutputDescriptor
6760  */
6761 struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_clone(const struct LDKSpendableOutputDescriptor *NONNULL_PTR orig);
6762
6763 /**
6764  * Serialize the SpendableOutputDescriptor object into a byte array which can be read by SpendableOutputDescriptor_read
6765  */
6766 struct LDKCVec_u8Z SpendableOutputDescriptor_write(const struct LDKSpendableOutputDescriptor *NONNULL_PTR obj);
6767
6768 /**
6769  * Read a SpendableOutputDescriptor from a byte array, created by SpendableOutputDescriptor_write
6770  */
6771 struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ SpendableOutputDescriptor_read(struct LDKu8slice ser);
6772
6773 /**
6774  * Creates a copy of a Sign
6775  */
6776 struct LDKSign Sign_clone(const struct LDKSign *NONNULL_PTR orig);
6777
6778 /**
6779  * Calls the free function if one is set
6780  */
6781 void Sign_free(struct LDKSign this_ptr);
6782
6783 /**
6784  * Calls the free function if one is set
6785  */
6786 void KeysInterface_free(struct LDKKeysInterface this_ptr);
6787
6788 /**
6789  * Frees any resources used by the InMemorySigner, if is_owned is set and inner is non-NULL.
6790  */
6791 void InMemorySigner_free(struct LDKInMemorySigner this_obj);
6792
6793 /**
6794  * Private key of anchor tx
6795  */
6796 const uint8_t (*InMemorySigner_get_funding_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
6797
6798 /**
6799  * Private key of anchor tx
6800  */
6801 void InMemorySigner_set_funding_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
6802
6803 /**
6804  * Holder secret key for blinded revocation pubkey
6805  */
6806 const uint8_t (*InMemorySigner_get_revocation_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
6807
6808 /**
6809  * Holder secret key for blinded revocation pubkey
6810  */
6811 void InMemorySigner_set_revocation_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
6812
6813 /**
6814  * Holder secret key used for our balance in counterparty-broadcasted commitment transactions
6815  */
6816 const uint8_t (*InMemorySigner_get_payment_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
6817
6818 /**
6819  * Holder secret key used for our balance in counterparty-broadcasted commitment transactions
6820  */
6821 void InMemorySigner_set_payment_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
6822
6823 /**
6824  * Holder secret key used in HTLC tx
6825  */
6826 const uint8_t (*InMemorySigner_get_delayed_payment_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
6827
6828 /**
6829  * Holder secret key used in HTLC tx
6830  */
6831 void InMemorySigner_set_delayed_payment_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
6832
6833 /**
6834  * Holder htlc secret key used in commitment tx htlc outputs
6835  */
6836 const uint8_t (*InMemorySigner_get_htlc_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
6837
6838 /**
6839  * Holder htlc secret key used in commitment tx htlc outputs
6840  */
6841 void InMemorySigner_set_htlc_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
6842
6843 /**
6844  * Commitment seed
6845  */
6846 const uint8_t (*InMemorySigner_get_commitment_seed(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
6847
6848 /**
6849  * Commitment seed
6850  */
6851 void InMemorySigner_set_commitment_seed(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
6852
6853 /**
6854  * Creates a copy of the InMemorySigner
6855  */
6856 struct LDKInMemorySigner InMemorySigner_clone(const struct LDKInMemorySigner *NONNULL_PTR orig);
6857
6858 /**
6859  * Create a new InMemorySigner
6860  */
6861 MUST_USE_RES struct LDKInMemorySigner InMemorySigner_new(struct LDKSecretKey funding_key, struct LDKSecretKey revocation_base_key, struct LDKSecretKey payment_key, struct LDKSecretKey delayed_payment_base_key, struct LDKSecretKey htlc_base_key, struct LDKThirtyTwoBytes commitment_seed, uint64_t channel_value_satoshis, struct LDKThirtyTwoBytes channel_keys_id);
6862
6863 /**
6864  * Counterparty pubkeys.
6865  * Will panic if ready_channel wasn't called.
6866  */
6867 MUST_USE_RES struct LDKChannelPublicKeys InMemorySigner_counterparty_pubkeys(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
6868
6869 /**
6870  * The contest_delay value specified by our counterparty and applied on holder-broadcastable
6871  * transactions, ie the amount of time that we have to wait to recover our funds if we
6872  * broadcast a transaction.
6873  * Will panic if ready_channel wasn't called.
6874  */
6875 MUST_USE_RES uint16_t InMemorySigner_counterparty_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
6876
6877 /**
6878  * The contest_delay value specified by us and applied on transactions broadcastable
6879  * by our counterparty, ie the amount of time that they have to wait to recover their funds
6880  * if they broadcast a transaction.
6881  * Will panic if ready_channel wasn't called.
6882  */
6883 MUST_USE_RES uint16_t InMemorySigner_holder_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
6884
6885 /**
6886  * Whether the holder is the initiator
6887  * Will panic if ready_channel wasn't called.
6888  */
6889 MUST_USE_RES bool InMemorySigner_is_outbound(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
6890
6891 /**
6892  * Funding outpoint
6893  * Will panic if ready_channel wasn't called.
6894  */
6895 MUST_USE_RES struct LDKOutPoint InMemorySigner_funding_outpoint(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
6896
6897 /**
6898  * Obtain a ChannelTransactionParameters for this channel, to be used when verifying or
6899  * building transactions.
6900  *
6901  * Will panic if ready_channel wasn't called.
6902  */
6903 MUST_USE_RES struct LDKChannelTransactionParameters InMemorySigner_get_channel_parameters(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
6904
6905 /**
6906  * Sign the single input of spend_tx at index `input_idx` which spends the output
6907  * described by descriptor, returning the witness stack for the input.
6908  *
6909  * Returns an Err if the input at input_idx does not exist, has a non-empty script_sig,
6910  * or is not spending the outpoint described by `descriptor.outpoint`.
6911  */
6912 MUST_USE_RES struct LDKCResult_CVec_CVec_u8ZZNoneZ InMemorySigner_sign_counterparty_payment_input(const struct LDKInMemorySigner *NONNULL_PTR this_arg, struct LDKTransaction spend_tx, uintptr_t input_idx, const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR descriptor);
6913
6914 /**
6915  * Sign the single input of spend_tx at index `input_idx` which spends the output
6916  * described by descriptor, returning the witness stack for the input.
6917  *
6918  * Returns an Err if the input at input_idx does not exist, has a non-empty script_sig,
6919  * is not spending the outpoint described by `descriptor.outpoint`, or does not have a
6920  * sequence set to `descriptor.to_self_delay`.
6921  */
6922 MUST_USE_RES struct LDKCResult_CVec_CVec_u8ZZNoneZ InMemorySigner_sign_dynamic_p2wsh_input(const struct LDKInMemorySigner *NONNULL_PTR this_arg, struct LDKTransaction spend_tx, uintptr_t input_idx, const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR descriptor);
6923
6924 /**
6925  * Constructs a new Sign which calls the relevant methods on this_arg.
6926  * This copies the `inner` pointer in this_arg and thus the returned Sign must be freed before this_arg is
6927  */
6928 struct LDKSign InMemorySigner_as_Sign(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
6929
6930 /**
6931  * Serialize the InMemorySigner object into a byte array which can be read by InMemorySigner_read
6932  */
6933 struct LDKCVec_u8Z InMemorySigner_write(const struct LDKInMemorySigner *NONNULL_PTR obj);
6934
6935 /**
6936  * Read a InMemorySigner from a byte array, created by InMemorySigner_write
6937  */
6938 struct LDKCResult_InMemorySignerDecodeErrorZ InMemorySigner_read(struct LDKu8slice ser);
6939
6940 /**
6941  * Frees any resources used by the KeysManager, if is_owned is set and inner is non-NULL.
6942  */
6943 void KeysManager_free(struct LDKKeysManager this_obj);
6944
6945 /**
6946  * Constructs a KeysManager from a 32-byte seed. If the seed is in some way biased (eg your
6947  * CSRNG is busted) this may panic (but more importantly, you will possibly lose funds).
6948  * starting_time isn't strictly required to actually be a time, but it must absolutely,
6949  * without a doubt, be unique to this instance. ie if you start multiple times with the same
6950  * seed, starting_time must be unique to each run. Thus, the easiest way to achieve this is to
6951  * simply use the current time (with very high precision).
6952  *
6953  * The seed MUST be backed up safely prior to use so that the keys can be re-created, however,
6954  * obviously, starting_time should be unique every time you reload the library - it is only
6955  * used to generate new ephemeral key data (which will be stored by the individual channel if
6956  * necessary).
6957  *
6958  * Note that the seed is required to recover certain on-chain funds independent of
6959  * ChannelMonitor data, though a current copy of ChannelMonitor data is also required for any
6960  * channel, and some on-chain during-closing funds.
6961  *
6962  * Note that until the 0.1 release there is no guarantee of backward compatibility between
6963  * versions. Once the library is more fully supported, the docs will be updated to include a
6964  * detailed description of the guarantee.
6965  */
6966 MUST_USE_RES struct LDKKeysManager KeysManager_new(const uint8_t (*seed)[32], uint64_t starting_time_secs, uint32_t starting_time_nanos);
6967
6968 /**
6969  * Derive an old Sign containing per-channel secrets based on a key derivation parameters.
6970  *
6971  * Key derivation parameters are accessible through a per-channel secrets
6972  * Sign::channel_keys_id and is provided inside DynamicOuputP2WSH in case of
6973  * onchain output detection for which a corresponding delayed_payment_key must be derived.
6974  */
6975 MUST_USE_RES struct LDKInMemorySigner KeysManager_derive_channel_keys(const struct LDKKeysManager *NONNULL_PTR this_arg, uint64_t channel_value_satoshis, const uint8_t (*params)[32]);
6976
6977 /**
6978  * Creates a Transaction which spends the given descriptors to the given outputs, plus an
6979  * output to the given change destination (if sufficient change value remains). The
6980  * transaction will have a feerate, at least, of the given value.
6981  *
6982  * Returns `Err(())` if the output value is greater than the input value minus required fee or
6983  * if a descriptor was duplicated.
6984  *
6985  * We do not enforce that outputs meet the dust limit or that any output scripts are standard.
6986  *
6987  * May panic if the `SpendableOutputDescriptor`s were not generated by Channels which used
6988  * this KeysManager or one of the `InMemorySigner` created by this KeysManager.
6989  */
6990 MUST_USE_RES struct LDKCResult_TransactionNoneZ KeysManager_spend_spendable_outputs(const struct LDKKeysManager *NONNULL_PTR this_arg, struct LDKCVec_SpendableOutputDescriptorZ descriptors, struct LDKCVec_TxOutZ outputs, struct LDKCVec_u8Z change_destination_script, uint32_t feerate_sat_per_1000_weight);
6991
6992 /**
6993  * Constructs a new KeysInterface which calls the relevant methods on this_arg.
6994  * This copies the `inner` pointer in this_arg and thus the returned KeysInterface must be freed before this_arg is
6995  */
6996 struct LDKKeysInterface KeysManager_as_KeysInterface(const struct LDKKeysManager *NONNULL_PTR this_arg);
6997
6998 /**
6999  * Frees any resources used by the ChannelManager, if is_owned is set and inner is non-NULL.
7000  */
7001 void ChannelManager_free(struct LDKChannelManager this_obj);
7002
7003 /**
7004  * Frees any resources used by the ChainParameters, if is_owned is set and inner is non-NULL.
7005  */
7006 void ChainParameters_free(struct LDKChainParameters this_obj);
7007
7008 /**
7009  * The network for determining the `chain_hash` in Lightning messages.
7010  */
7011 enum LDKNetwork ChainParameters_get_network(const struct LDKChainParameters *NONNULL_PTR this_ptr);
7012
7013 /**
7014  * The network for determining the `chain_hash` in Lightning messages.
7015  */
7016 void ChainParameters_set_network(struct LDKChainParameters *NONNULL_PTR this_ptr, enum LDKNetwork val);
7017
7018 /**
7019  * The hash of the latest block successfully connected.
7020  */
7021 const uint8_t (*ChainParameters_get_latest_hash(const struct LDKChainParameters *NONNULL_PTR this_ptr))[32];
7022
7023 /**
7024  * The hash of the latest block successfully connected.
7025  */
7026 void ChainParameters_set_latest_hash(struct LDKChainParameters *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
7027
7028 /**
7029  * The height of the latest block successfully connected.
7030  *
7031  * Used to track on-chain channel funding outputs and send payments with reliable timelocks.
7032  */
7033 uintptr_t ChainParameters_get_latest_height(const struct LDKChainParameters *NONNULL_PTR this_ptr);
7034
7035 /**
7036  * The height of the latest block successfully connected.
7037  *
7038  * Used to track on-chain channel funding outputs and send payments with reliable timelocks.
7039  */
7040 void ChainParameters_set_latest_height(struct LDKChainParameters *NONNULL_PTR this_ptr, uintptr_t val);
7041
7042 /**
7043  * Constructs a new ChainParameters given each field
7044  */
7045 MUST_USE_RES struct LDKChainParameters ChainParameters_new(enum LDKNetwork network_arg, struct LDKThirtyTwoBytes latest_hash_arg, uintptr_t latest_height_arg);
7046
7047 /**
7048  * Frees any resources used by the ChannelDetails, if is_owned is set and inner is non-NULL.
7049  */
7050 void ChannelDetails_free(struct LDKChannelDetails this_obj);
7051
7052 /**
7053  * The channel's ID (prior to funding transaction generation, this is a random 32 bytes,
7054  * thereafter this is the txid of the funding transaction xor the funding transaction output).
7055  * Note that this means this value is *not* persistent - it can change once during the
7056  * lifetime of the channel.
7057  */
7058 const uint8_t (*ChannelDetails_get_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr))[32];
7059
7060 /**
7061  * The channel's ID (prior to funding transaction generation, this is a random 32 bytes,
7062  * thereafter this is the txid of the funding transaction xor the funding transaction output).
7063  * Note that this means this value is *not* persistent - it can change once during the
7064  * lifetime of the channel.
7065  */
7066 void ChannelDetails_set_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
7067
7068 /**
7069  * The node_id of our counterparty
7070  */
7071 struct LDKPublicKey ChannelDetails_get_remote_network_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
7072
7073 /**
7074  * The node_id of our counterparty
7075  */
7076 void ChannelDetails_set_remote_network_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKPublicKey val);
7077
7078 /**
7079  * The Features the channel counterparty provided upon last connection.
7080  * Useful for routing as it is the most up-to-date copy of the counterparty's features and
7081  * many routing-relevant features are present in the init context.
7082  */
7083 struct LDKInitFeatures ChannelDetails_get_counterparty_features(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
7084
7085 /**
7086  * The Features the channel counterparty provided upon last connection.
7087  * Useful for routing as it is the most up-to-date copy of the counterparty's features and
7088  * many routing-relevant features are present in the init context.
7089  */
7090 void ChannelDetails_set_counterparty_features(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
7091
7092 /**
7093  * The value, in satoshis, of this channel as appears in the funding output
7094  */
7095 uint64_t ChannelDetails_get_channel_value_satoshis(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
7096
7097 /**
7098  * The value, in satoshis, of this channel as appears in the funding output
7099  */
7100 void ChannelDetails_set_channel_value_satoshis(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
7101
7102 /**
7103  * The user_id passed in to create_channel, or 0 if the channel was inbound.
7104  */
7105 uint64_t ChannelDetails_get_user_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
7106
7107 /**
7108  * The user_id passed in to create_channel, or 0 if the channel was inbound.
7109  */
7110 void ChannelDetails_set_user_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
7111
7112 /**
7113  * The available outbound capacity for sending HTLCs to the remote peer. This does not include
7114  * any pending HTLCs which are not yet fully resolved (and, thus, who's balance is not
7115  * available for inclusion in new outbound HTLCs). This further does not include any pending
7116  * outgoing HTLCs which are awaiting some other resolution to be sent.
7117  */
7118 uint64_t ChannelDetails_get_outbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
7119
7120 /**
7121  * The available outbound capacity for sending HTLCs to the remote peer. This does not include
7122  * any pending HTLCs which are not yet fully resolved (and, thus, who's balance is not
7123  * available for inclusion in new outbound HTLCs). This further does not include any pending
7124  * outgoing HTLCs which are awaiting some other resolution to be sent.
7125  */
7126 void ChannelDetails_set_outbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
7127
7128 /**
7129  * The available inbound capacity for the remote peer to send HTLCs to us. This does not
7130  * include any pending HTLCs which are not yet fully resolved (and, thus, who's balance is not
7131  * available for inclusion in new inbound HTLCs).
7132  * Note that there are some corner cases not fully handled here, so the actual available
7133  * inbound capacity may be slightly higher than this.
7134  */
7135 uint64_t ChannelDetails_get_inbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
7136
7137 /**
7138  * The available inbound capacity for the remote peer to send HTLCs to us. This does not
7139  * include any pending HTLCs which are not yet fully resolved (and, thus, who's balance is not
7140  * available for inclusion in new inbound HTLCs).
7141  * Note that there are some corner cases not fully handled here, so the actual available
7142  * inbound capacity may be slightly higher than this.
7143  */
7144 void ChannelDetails_set_inbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
7145
7146 /**
7147  * True if the channel is (a) confirmed and funding_locked messages have been exchanged, (b)
7148  * the peer is connected, and (c) no monitor update failure is pending resolution.
7149  */
7150 bool ChannelDetails_get_is_live(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
7151
7152 /**
7153  * True if the channel is (a) confirmed and funding_locked messages have been exchanged, (b)
7154  * the peer is connected, and (c) no monitor update failure is pending resolution.
7155  */
7156 void ChannelDetails_set_is_live(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
7157
7158 /**
7159  * Creates a copy of the ChannelDetails
7160  */
7161 struct LDKChannelDetails ChannelDetails_clone(const struct LDKChannelDetails *NONNULL_PTR orig);
7162
7163 /**
7164  * Frees any resources used by the PaymentSendFailure
7165  */
7166 void PaymentSendFailure_free(struct LDKPaymentSendFailure this_ptr);
7167
7168 /**
7169  * Creates a copy of the PaymentSendFailure
7170  */
7171 struct LDKPaymentSendFailure PaymentSendFailure_clone(const struct LDKPaymentSendFailure *NONNULL_PTR orig);
7172
7173 /**
7174  * Constructs a new ChannelManager to hold several channels and route between them.
7175  *
7176  * This is the main \"logic hub\" for all channel-related actions, and implements
7177  * ChannelMessageHandler.
7178  *
7179  * Non-proportional fees are fixed according to our risk using the provided fee estimator.
7180  *
7181  * panics if channel_value_satoshis is >= `MAX_FUNDING_SATOSHIS`!
7182  *
7183  * Users need to notify the new ChannelManager when a new block is connected or
7184  * disconnected using its `block_connected` and `block_disconnected` methods, starting
7185  * from after `params.latest_hash`.
7186  */
7187 MUST_USE_RES struct LDKChannelManager ChannelManager_new(struct LDKFeeEstimator fee_est, struct LDKWatch chain_monitor, struct LDKBroadcasterInterface tx_broadcaster, struct LDKLogger logger, struct LDKKeysInterface keys_manager, struct LDKUserConfig config, struct LDKChainParameters params);
7188
7189 /**
7190  * Creates a new outbound channel to the given remote node and with the given value.
7191  *
7192  * user_id will be provided back as user_channel_id in FundingGenerationReady and
7193  * FundingBroadcastSafe events to allow tracking of which events correspond with which
7194  * create_channel call. Note that user_channel_id defaults to 0 for inbound channels, so you
7195  * may wish to avoid using 0 for user_id here.
7196  *
7197  * If successful, will generate a SendOpenChannel message event, so you should probably poll
7198  * PeerManager::process_events afterwards.
7199  *
7200  * Raises APIError::APIMisuseError when channel_value_satoshis > 2**24 or push_msat is
7201  * greater than channel_value_satoshis * 1k or channel_value_satoshis is < 1000.
7202  */
7203 MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_create_channel(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKPublicKey their_network_key, uint64_t channel_value_satoshis, uint64_t push_msat, uint64_t user_id, struct LDKUserConfig override_config);
7204
7205 /**
7206  * Gets the list of open channels, in random order. See ChannelDetail field documentation for
7207  * more information.
7208  */
7209 MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
7210
7211 /**
7212  * Gets the list of usable channels, in random order. Useful as an argument to
7213  * get_route to ensure non-announced channels are used.
7214  *
7215  * These are guaranteed to have their is_live value set to true, see the documentation for
7216  * ChannelDetails::is_live for more info on exactly what the criteria are.
7217  */
7218 MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_usable_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
7219
7220 /**
7221  * Begins the process of closing a channel. After this call (plus some timeout), no new HTLCs
7222  * will be accepted on the given channel, and after additional timeout/the closing of all
7223  * pending HTLCs, the channel will be closed on chain.
7224  *
7225  * May generate a SendShutdown message event on success, which should be relayed.
7226  */
7227 MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_close_channel(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*channel_id)[32]);
7228
7229 /**
7230  * Force closes a channel, immediately broadcasting the latest local commitment transaction to
7231  * the chain and rejecting new HTLCs on the given channel. Fails if channel_id is unknown to the manager.
7232  */
7233 MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_force_close_channel(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*channel_id)[32]);
7234
7235 /**
7236  * Force close all channels, immediately broadcasting the latest local commitment transaction
7237  * for each to the chain and rejecting new HTLCs on each.
7238  */
7239 void ChannelManager_force_close_all_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
7240
7241 /**
7242  * Sends a payment along a given route.
7243  *
7244  * Value parameters are provided via the last hop in route, see documentation for RouteHop
7245  * fields for more info.
7246  *
7247  * Note that if the payment_hash already exists elsewhere (eg you're sending a duplicative
7248  * payment), we don't do anything to stop you! We always try to ensure that if the provided
7249  * next hop knows the preimage to payment_hash they can claim an additional amount as
7250  * specified in the last hop in the route! Thus, you should probably do your own
7251  * payment_preimage tracking (which you should already be doing as they represent \"proof of
7252  * payment\") and prevent double-sends yourself.
7253  *
7254  * May generate SendHTLCs message(s) event on success, which should be relayed.
7255  *
7256  * Each path may have a different return value, and PaymentSendValue may return a Vec with
7257  * each entry matching the corresponding-index entry in the route paths, see
7258  * PaymentSendFailure for more info.
7259  *
7260  * In general, a path may raise:
7261  *  * APIError::RouteError when an invalid route or forwarding parameter (cltv_delta, fee,
7262  *    node public key) is specified.
7263  *  * APIError::ChannelUnavailable if the next-hop channel is not available for updates
7264  *    (including due to previous monitor update failure or new permanent monitor update
7265  *    failure).
7266  *  * APIError::MonitorUpdateFailed if a new monitor update failure prevented sending the
7267  *    relevant updates.
7268  *
7269  * Note that depending on the type of the PaymentSendFailure the HTLC may have been
7270  * irrevocably committed to on our end. In such a case, do NOT retry the payment with a
7271  * different route unless you intend to pay twice!
7272  *
7273  * payment_secret is unrelated to payment_hash (or PaymentPreimage) and exists to authenticate
7274  * the sender to the recipient and prevent payment-probing (deanonymization) attacks. For
7275  * newer nodes, it will be provided to you in the invoice. If you do not have one, the Route
7276  * must not contain multiple paths as multi-path payments require a recipient-provided
7277  * payment_secret.
7278  * If a payment_secret *is* provided, we assume that the invoice had the payment_secret feature
7279  * bit set (either as required or as available). If multiple paths are present in the Route,
7280  * we assume the invoice had the basic_mpp feature set.
7281  */
7282 MUST_USE_RES struct LDKCResult_NonePaymentSendFailureZ ChannelManager_send_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_hash, struct LDKThirtyTwoBytes payment_secret);
7283
7284 /**
7285  * Call this upon creation of a funding transaction for the given channel.
7286  *
7287  * Note that ALL inputs in the transaction pointed to by funding_txo MUST spend SegWit outputs
7288  * or your counterparty can steal your funds!
7289  *
7290  * Panics if a funding transaction has already been provided for this channel.
7291  *
7292  * May panic if the funding_txo is duplicative with some other channel (note that this should
7293  * be trivially prevented by using unique funding transaction keys per-channel).
7294  */
7295 void ChannelManager_funding_transaction_generated(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*temporary_channel_id)[32], struct LDKOutPoint funding_txo);
7296
7297 /**
7298  * Generates a signed node_announcement from the given arguments and creates a
7299  * BroadcastNodeAnnouncement event. Note that such messages will be ignored unless peers have
7300  * seen a channel_announcement from us (ie unless we have public channels open).
7301  *
7302  * RGB is a node \"color\" and alias is a printable human-readable string to describe this node
7303  * to humans. They carry no in-protocol meaning.
7304  *
7305  * addresses represent the set (possibly empty) of socket addresses on which this node accepts
7306  * incoming connections. These will be broadcast to the network, publicly tying these
7307  * addresses together. If you wish to preserve user privacy, addresses should likely contain
7308  * only Tor Onion addresses.
7309  *
7310  * Panics if addresses is absurdly large (more than 500).
7311  */
7312 void ChannelManager_broadcast_node_announcement(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThreeBytes rgb, struct LDKThirtyTwoBytes alias, struct LDKCVec_NetAddressZ addresses);
7313
7314 /**
7315  * Processes HTLCs which are pending waiting on random forward delay.
7316  *
7317  * Should only really ever be called in response to a PendingHTLCsForwardable event.
7318  * Will likely generate further events.
7319  */
7320 void ChannelManager_process_pending_htlc_forwards(const struct LDKChannelManager *NONNULL_PTR this_arg);
7321
7322 /**
7323  * If a peer is disconnected we mark any channels with that peer as 'disabled'.
7324  * After some time, if channels are still disabled we need to broadcast a ChannelUpdate
7325  * to inform the network about the uselessness of these channels.
7326  *
7327  * This method handles all the details, and must be called roughly once per minute.
7328  *
7329  * Note that in some rare cases this may generate a `chain::Watch::update_channel` call.
7330  */
7331 void ChannelManager_timer_chan_freshness_every_min(const struct LDKChannelManager *NONNULL_PTR this_arg);
7332
7333 /**
7334  * Indicates that the preimage for payment_hash is unknown or the received amount is incorrect
7335  * after a PaymentReceived event, failing the HTLC back to its origin and freeing resources
7336  * along the path (including in our own channel on which we received it).
7337  * Returns false if no payment was found to fail backwards, true if the process of failing the
7338  * HTLC backwards has been started.
7339  */
7340 MUST_USE_RES bool ChannelManager_fail_htlc_backwards(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32], struct LDKThirtyTwoBytes payment_secret);
7341
7342 /**
7343  * Provides a payment preimage in response to a PaymentReceived event, returning true and
7344  * generating message events for the net layer to claim the payment, if possible. Thus, you
7345  * should probably kick the net layer to go send messages if this returns true!
7346  *
7347  * You must specify the expected amounts for this HTLC, and we will only claim HTLCs
7348  * available within a few percent of the expected amount. This is critical for several
7349  * reasons : a) it avoids providing senders with `proof-of-payment` (in the form of the
7350  * payment_preimage without having provided the full value and b) it avoids certain
7351  * privacy-breaking recipient-probing attacks which may reveal payment activity to
7352  * motivated attackers.
7353  *
7354  * Note that the privacy concerns in (b) are not relevant in payments with a payment_secret
7355  * set. Thus, for such payments we will claim any payments which do not under-pay.
7356  *
7357  * May panic if called except in response to a PaymentReceived event.
7358  */
7359 MUST_USE_RES bool ChannelManager_claim_funds(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_secret, uint64_t expected_amount);
7360
7361 /**
7362  * Gets the node_id held by this ChannelManager
7363  */
7364 MUST_USE_RES struct LDKPublicKey ChannelManager_get_our_node_id(const struct LDKChannelManager *NONNULL_PTR this_arg);
7365
7366 /**
7367  * Restores a single, given channel to normal operation after a
7368  * ChannelMonitorUpdateErr::TemporaryFailure was returned from a channel monitor update
7369  * operation.
7370  *
7371  * All ChannelMonitor updates up to and including highest_applied_update_id must have been
7372  * fully committed in every copy of the given channels' ChannelMonitors.
7373  *
7374  * Note that there is no effect to calling with a highest_applied_update_id other than the
7375  * current latest ChannelMonitorUpdate and one call to this function after multiple
7376  * ChannelMonitorUpdateErr::TemporaryFailures is fine. The highest_applied_update_id field
7377  * exists largely only to prevent races between this and concurrent update_monitor calls.
7378  *
7379  * Thus, the anticipated use is, at a high level:
7380  *  1) You register a chain::Watch with this ChannelManager,
7381  *  2) it stores each update to disk, and begins updating any remote (eg watchtower) copies of
7382  *     said ChannelMonitors as it can, returning ChannelMonitorUpdateErr::TemporaryFailures
7383  *     any time it cannot do so instantly,
7384  *  3) update(s) are applied to each remote copy of a ChannelMonitor,
7385  *  4) once all remote copies are updated, you call this function with the update_id that
7386  *     completed, and once it is the latest the Channel will be re-enabled.
7387  */
7388 void ChannelManager_channel_monitor_updated(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKOutPoint *NONNULL_PTR funding_txo, uint64_t highest_applied_update_id);
7389
7390 /**
7391  * Constructs a new MessageSendEventsProvider which calls the relevant methods on this_arg.
7392  * This copies the `inner` pointer in this_arg and thus the returned MessageSendEventsProvider must be freed before this_arg is
7393  */
7394 struct LDKMessageSendEventsProvider ChannelManager_as_MessageSendEventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
7395
7396 /**
7397  * Constructs a new EventsProvider which calls the relevant methods on this_arg.
7398  * This copies the `inner` pointer in this_arg and thus the returned EventsProvider must be freed before this_arg is
7399  */
7400 struct LDKEventsProvider ChannelManager_as_EventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
7401
7402 /**
7403  * Constructs a new Listen which calls the relevant methods on this_arg.
7404  * This copies the `inner` pointer in this_arg and thus the returned Listen must be freed before this_arg is
7405  */
7406 struct LDKListen ChannelManager_as_Listen(const struct LDKChannelManager *NONNULL_PTR this_arg);
7407
7408 /**
7409  * Updates channel state based on transactions seen in a connected block.
7410  */
7411 void ChannelManager_block_connected(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height);
7412
7413 /**
7414  * Updates channel state based on a disconnected block.
7415  *
7416  * If necessary, the channel may be force-closed without letting the counterparty participate
7417  * in the shutdown.
7418  */
7419 void ChannelManager_block_disconnected(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*header)[80]);
7420
7421 /**
7422  * Blocks until ChannelManager needs to be persisted. Only one listener on
7423  * `await_persistable_update` or `await_persistable_update_timeout` is guaranteed to be woken
7424  * up.
7425  */
7426 void ChannelManager_await_persistable_update(const struct LDKChannelManager *NONNULL_PTR this_arg);
7427
7428 /**
7429  * Constructs a new ChannelMessageHandler which calls the relevant methods on this_arg.
7430  * This copies the `inner` pointer in this_arg and thus the returned ChannelMessageHandler must be freed before this_arg is
7431  */
7432 struct LDKChannelMessageHandler ChannelManager_as_ChannelMessageHandler(const struct LDKChannelManager *NONNULL_PTR this_arg);
7433
7434 /**
7435  * Serialize the ChannelManager object into a byte array which can be read by ChannelManager_read
7436  */
7437 struct LDKCVec_u8Z ChannelManager_write(const struct LDKChannelManager *NONNULL_PTR obj);
7438
7439 /**
7440  * Frees any resources used by the ChannelManagerReadArgs, if is_owned is set and inner is non-NULL.
7441  */
7442 void ChannelManagerReadArgs_free(struct LDKChannelManagerReadArgs this_obj);
7443
7444 /**
7445  * The keys provider which will give us relevant keys. Some keys will be loaded during
7446  * deserialization and KeysInterface::read_chan_signer will be used to read per-Channel
7447  * signing data.
7448  */
7449 const struct LDKKeysInterface *ChannelManagerReadArgs_get_keys_manager(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
7450
7451 /**
7452  * The keys provider which will give us relevant keys. Some keys will be loaded during
7453  * deserialization and KeysInterface::read_chan_signer will be used to read per-Channel
7454  * signing data.
7455  */
7456 void ChannelManagerReadArgs_set_keys_manager(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKKeysInterface val);
7457
7458 /**
7459  * The fee_estimator for use in the ChannelManager in the future.
7460  *
7461  * No calls to the FeeEstimator will be made during deserialization.
7462  */
7463 const struct LDKFeeEstimator *ChannelManagerReadArgs_get_fee_estimator(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
7464
7465 /**
7466  * The fee_estimator for use in the ChannelManager in the future.
7467  *
7468  * No calls to the FeeEstimator will be made during deserialization.
7469  */
7470 void ChannelManagerReadArgs_set_fee_estimator(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKFeeEstimator val);
7471
7472 /**
7473  * The chain::Watch for use in the ChannelManager in the future.
7474  *
7475  * No calls to the chain::Watch will be made during deserialization. It is assumed that
7476  * you have deserialized ChannelMonitors separately and will add them to your
7477  * chain::Watch after deserializing this ChannelManager.
7478  */
7479 const struct LDKWatch *ChannelManagerReadArgs_get_chain_monitor(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
7480
7481 /**
7482  * The chain::Watch for use in the ChannelManager in the future.
7483  *
7484  * No calls to the chain::Watch will be made during deserialization. It is assumed that
7485  * you have deserialized ChannelMonitors separately and will add them to your
7486  * chain::Watch after deserializing this ChannelManager.
7487  */
7488 void ChannelManagerReadArgs_set_chain_monitor(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKWatch val);
7489
7490 /**
7491  * The BroadcasterInterface which will be used in the ChannelManager in the future and may be
7492  * used to broadcast the latest local commitment transactions of channels which must be
7493  * force-closed during deserialization.
7494  */
7495 const struct LDKBroadcasterInterface *ChannelManagerReadArgs_get_tx_broadcaster(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
7496
7497 /**
7498  * The BroadcasterInterface which will be used in the ChannelManager in the future and may be
7499  * used to broadcast the latest local commitment transactions of channels which must be
7500  * force-closed during deserialization.
7501  */
7502 void ChannelManagerReadArgs_set_tx_broadcaster(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKBroadcasterInterface val);
7503
7504 /**
7505  * The Logger for use in the ChannelManager and which may be used to log information during
7506  * deserialization.
7507  */
7508 const struct LDKLogger *ChannelManagerReadArgs_get_logger(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
7509
7510 /**
7511  * The Logger for use in the ChannelManager and which may be used to log information during
7512  * deserialization.
7513  */
7514 void ChannelManagerReadArgs_set_logger(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKLogger val);
7515
7516 /**
7517  * Default settings used for new channels. Any existing channels will continue to use the
7518  * runtime settings which were stored when the ChannelManager was serialized.
7519  */
7520 struct LDKUserConfig ChannelManagerReadArgs_get_default_config(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
7521
7522 /**
7523  * Default settings used for new channels. Any existing channels will continue to use the
7524  * runtime settings which were stored when the ChannelManager was serialized.
7525  */
7526 void ChannelManagerReadArgs_set_default_config(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKUserConfig val);
7527
7528 /**
7529  * Simple utility function to create a ChannelManagerReadArgs which creates the monitor
7530  * HashMap for you. This is primarily useful for C bindings where it is not practical to
7531  * populate a HashMap directly from C.
7532  */
7533 MUST_USE_RES struct LDKChannelManagerReadArgs ChannelManagerReadArgs_new(struct LDKKeysInterface keys_manager, struct LDKFeeEstimator fee_estimator, struct LDKWatch chain_monitor, struct LDKBroadcasterInterface tx_broadcaster, struct LDKLogger logger, struct LDKUserConfig default_config, struct LDKCVec_ChannelMonitorZ channel_monitors);
7534
7535 /**
7536  * Read a C2Tuple_BlockHashChannelManagerZ from a byte array, created by C2Tuple_BlockHashChannelManagerZ_write
7537  */
7538 struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ C2Tuple_BlockHashChannelManagerZ_read(struct LDKu8slice ser, struct LDKChannelManagerReadArgs arg);
7539
7540 /**
7541  * Frees any resources used by the DecodeError, if is_owned is set and inner is non-NULL.
7542  */
7543 void DecodeError_free(struct LDKDecodeError this_obj);
7544
7545 /**
7546  * Creates a copy of the DecodeError
7547  */
7548 struct LDKDecodeError DecodeError_clone(const struct LDKDecodeError *NONNULL_PTR orig);
7549
7550 /**
7551  * Frees any resources used by the Init, if is_owned is set and inner is non-NULL.
7552  */
7553 void Init_free(struct LDKInit this_obj);
7554
7555 /**
7556  * The relevant features which the sender supports
7557  */
7558 struct LDKInitFeatures Init_get_features(const struct LDKInit *NONNULL_PTR this_ptr);
7559
7560 /**
7561  * The relevant features which the sender supports
7562  */
7563 void Init_set_features(struct LDKInit *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
7564
7565 /**
7566  * Constructs a new Init given each field
7567  */
7568 MUST_USE_RES struct LDKInit Init_new(struct LDKInitFeatures features_arg);
7569
7570 /**
7571  * Creates a copy of the Init
7572  */
7573 struct LDKInit Init_clone(const struct LDKInit *NONNULL_PTR orig);
7574
7575 /**
7576  * Frees any resources used by the ErrorMessage, if is_owned is set and inner is non-NULL.
7577  */
7578 void ErrorMessage_free(struct LDKErrorMessage this_obj);
7579
7580 /**
7581  * The channel ID involved in the error
7582  */
7583 const uint8_t (*ErrorMessage_get_channel_id(const struct LDKErrorMessage *NONNULL_PTR this_ptr))[32];
7584
7585 /**
7586  * The channel ID involved in the error
7587  */
7588 void ErrorMessage_set_channel_id(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
7589
7590 /**
7591  * A possibly human-readable error description.
7592  * The string should be sanitized before it is used (e.g. emitted to logs
7593  * or printed to stdout).  Otherwise, a well crafted error message may trigger a security
7594  * vulnerability in the terminal emulator or the logging subsystem.
7595  */
7596 struct LDKStr ErrorMessage_get_data(const struct LDKErrorMessage *NONNULL_PTR this_ptr);
7597
7598 /**
7599  * A possibly human-readable error description.
7600  * The string should be sanitized before it is used (e.g. emitted to logs
7601  * or printed to stdout).  Otherwise, a well crafted error message may trigger a security
7602  * vulnerability in the terminal emulator or the logging subsystem.
7603  */
7604 void ErrorMessage_set_data(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
7605
7606 /**
7607  * Constructs a new ErrorMessage given each field
7608  */
7609 MUST_USE_RES struct LDKErrorMessage ErrorMessage_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKCVec_u8Z data_arg);
7610
7611 /**
7612  * Creates a copy of the ErrorMessage
7613  */
7614 struct LDKErrorMessage ErrorMessage_clone(const struct LDKErrorMessage *NONNULL_PTR orig);
7615
7616 /**
7617  * Frees any resources used by the Ping, if is_owned is set and inner is non-NULL.
7618  */
7619 void Ping_free(struct LDKPing this_obj);
7620
7621 /**
7622  * The desired response length
7623  */
7624 uint16_t Ping_get_ponglen(const struct LDKPing *NONNULL_PTR this_ptr);
7625
7626 /**
7627  * The desired response length
7628  */
7629 void Ping_set_ponglen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
7630
7631 /**
7632  * The ping packet size.
7633  * This field is not sent on the wire. byteslen zeros are sent.
7634  */
7635 uint16_t Ping_get_byteslen(const struct LDKPing *NONNULL_PTR this_ptr);
7636
7637 /**
7638  * The ping packet size.
7639  * This field is not sent on the wire. byteslen zeros are sent.
7640  */
7641 void Ping_set_byteslen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
7642
7643 /**
7644  * Constructs a new Ping given each field
7645  */
7646 MUST_USE_RES struct LDKPing Ping_new(uint16_t ponglen_arg, uint16_t byteslen_arg);
7647
7648 /**
7649  * Creates a copy of the Ping
7650  */
7651 struct LDKPing Ping_clone(const struct LDKPing *NONNULL_PTR orig);
7652
7653 /**
7654  * Frees any resources used by the Pong, if is_owned is set and inner is non-NULL.
7655  */
7656 void Pong_free(struct LDKPong this_obj);
7657
7658 /**
7659  * The pong packet size.
7660  * This field is not sent on the wire. byteslen zeros are sent.
7661  */
7662 uint16_t Pong_get_byteslen(const struct LDKPong *NONNULL_PTR this_ptr);
7663
7664 /**
7665  * The pong packet size.
7666  * This field is not sent on the wire. byteslen zeros are sent.
7667  */
7668 void Pong_set_byteslen(struct LDKPong *NONNULL_PTR this_ptr, uint16_t val);
7669
7670 /**
7671  * Constructs a new Pong given each field
7672  */
7673 MUST_USE_RES struct LDKPong Pong_new(uint16_t byteslen_arg);
7674
7675 /**
7676  * Creates a copy of the Pong
7677  */
7678 struct LDKPong Pong_clone(const struct LDKPong *NONNULL_PTR orig);
7679
7680 /**
7681  * Frees any resources used by the OpenChannel, if is_owned is set and inner is non-NULL.
7682  */
7683 void OpenChannel_free(struct LDKOpenChannel this_obj);
7684
7685 /**
7686  * The genesis hash of the blockchain where the channel is to be opened
7687  */
7688 const uint8_t (*OpenChannel_get_chain_hash(const struct LDKOpenChannel *NONNULL_PTR this_ptr))[32];
7689
7690 /**
7691  * The genesis hash of the blockchain where the channel is to be opened
7692  */
7693 void OpenChannel_set_chain_hash(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
7694
7695 /**
7696  * A temporary channel ID, until the funding outpoint is announced
7697  */
7698 const uint8_t (*OpenChannel_get_temporary_channel_id(const struct LDKOpenChannel *NONNULL_PTR this_ptr))[32];
7699
7700 /**
7701  * A temporary channel ID, until the funding outpoint is announced
7702  */
7703 void OpenChannel_set_temporary_channel_id(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
7704
7705 /**
7706  * The channel value
7707  */
7708 uint64_t OpenChannel_get_funding_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
7709
7710 /**
7711  * The channel value
7712  */
7713 void OpenChannel_set_funding_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
7714
7715 /**
7716  * The amount to push to the counterparty as part of the open, in milli-satoshi
7717  */
7718 uint64_t OpenChannel_get_push_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
7719
7720 /**
7721  * The amount to push to the counterparty as part of the open, in milli-satoshi
7722  */
7723 void OpenChannel_set_push_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
7724
7725 /**
7726  * The threshold below which outputs on transactions broadcast by sender will be omitted
7727  */
7728 uint64_t OpenChannel_get_dust_limit_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
7729
7730 /**
7731  * The threshold below which outputs on transactions broadcast by sender will be omitted
7732  */
7733 void OpenChannel_set_dust_limit_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
7734
7735 /**
7736  * The maximum inbound HTLC value in flight towards sender, in milli-satoshi
7737  */
7738 uint64_t OpenChannel_get_max_htlc_value_in_flight_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
7739
7740 /**
7741  * The maximum inbound HTLC value in flight towards sender, in milli-satoshi
7742  */
7743 void OpenChannel_set_max_htlc_value_in_flight_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
7744
7745 /**
7746  * The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
7747  */
7748 uint64_t OpenChannel_get_channel_reserve_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
7749
7750 /**
7751  * The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
7752  */
7753 void OpenChannel_set_channel_reserve_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
7754
7755 /**
7756  * The minimum HTLC size incoming to sender, in milli-satoshi
7757  */
7758 uint64_t OpenChannel_get_htlc_minimum_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
7759
7760 /**
7761  * The minimum HTLC size incoming to sender, in milli-satoshi
7762  */
7763 void OpenChannel_set_htlc_minimum_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
7764
7765 /**
7766  * The feerate per 1000-weight of sender generated transactions, until updated by update_fee
7767  */
7768 uint32_t OpenChannel_get_feerate_per_kw(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
7769
7770 /**
7771  * The feerate per 1000-weight of sender generated transactions, until updated by update_fee
7772  */
7773 void OpenChannel_set_feerate_per_kw(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint32_t val);
7774
7775 /**
7776  * The number of blocks which the counterparty will have to wait to claim on-chain funds if they broadcast a commitment transaction
7777  */
7778 uint16_t OpenChannel_get_to_self_delay(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
7779
7780 /**
7781  * The number of blocks which the counterparty will have to wait to claim on-chain funds if they broadcast a commitment transaction
7782  */
7783 void OpenChannel_set_to_self_delay(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint16_t val);
7784
7785 /**
7786  * The maximum number of inbound HTLCs towards sender
7787  */
7788 uint16_t OpenChannel_get_max_accepted_htlcs(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
7789
7790 /**
7791  * The maximum number of inbound HTLCs towards sender
7792  */
7793 void OpenChannel_set_max_accepted_htlcs(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint16_t val);
7794
7795 /**
7796  * The sender's key controlling the funding transaction
7797  */
7798 struct LDKPublicKey OpenChannel_get_funding_pubkey(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
7799
7800 /**
7801  * The sender's key controlling the funding transaction
7802  */
7803 void OpenChannel_set_funding_pubkey(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
7804
7805 /**
7806  * Used to derive a revocation key for transactions broadcast by counterparty
7807  */
7808 struct LDKPublicKey OpenChannel_get_revocation_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
7809
7810 /**
7811  * Used to derive a revocation key for transactions broadcast by counterparty
7812  */
7813 void OpenChannel_set_revocation_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
7814
7815 /**
7816  * A payment key to sender for transactions broadcast by counterparty
7817  */
7818 struct LDKPublicKey OpenChannel_get_payment_point(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
7819
7820 /**
7821  * A payment key to sender for transactions broadcast by counterparty
7822  */
7823 void OpenChannel_set_payment_point(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
7824
7825 /**
7826  * Used to derive a payment key to sender for transactions broadcast by sender
7827  */
7828 struct LDKPublicKey OpenChannel_get_delayed_payment_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
7829
7830 /**
7831  * Used to derive a payment key to sender for transactions broadcast by sender
7832  */
7833 void OpenChannel_set_delayed_payment_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
7834
7835 /**
7836  * Used to derive an HTLC payment key to sender
7837  */
7838 struct LDKPublicKey OpenChannel_get_htlc_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
7839
7840 /**
7841  * Used to derive an HTLC payment key to sender
7842  */
7843 void OpenChannel_set_htlc_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
7844
7845 /**
7846  * The first to-be-broadcast-by-sender transaction's per commitment point
7847  */
7848 struct LDKPublicKey OpenChannel_get_first_per_commitment_point(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
7849
7850 /**
7851  * The first to-be-broadcast-by-sender transaction's per commitment point
7852  */
7853 void OpenChannel_set_first_per_commitment_point(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
7854
7855 /**
7856  * Channel flags
7857  */
7858 uint8_t OpenChannel_get_channel_flags(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
7859
7860 /**
7861  * Channel flags
7862  */
7863 void OpenChannel_set_channel_flags(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint8_t val);
7864
7865 /**
7866  * Creates a copy of the OpenChannel
7867  */
7868 struct LDKOpenChannel OpenChannel_clone(const struct LDKOpenChannel *NONNULL_PTR orig);
7869
7870 /**
7871  * Frees any resources used by the AcceptChannel, if is_owned is set and inner is non-NULL.
7872  */
7873 void AcceptChannel_free(struct LDKAcceptChannel this_obj);
7874
7875 /**
7876  * A temporary channel ID, until the funding outpoint is announced
7877  */
7878 const uint8_t (*AcceptChannel_get_temporary_channel_id(const struct LDKAcceptChannel *NONNULL_PTR this_ptr))[32];
7879
7880 /**
7881  * A temporary channel ID, until the funding outpoint is announced
7882  */
7883 void AcceptChannel_set_temporary_channel_id(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
7884
7885 /**
7886  * The threshold below which outputs on transactions broadcast by sender will be omitted
7887  */
7888 uint64_t AcceptChannel_get_dust_limit_satoshis(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
7889
7890 /**
7891  * The threshold below which outputs on transactions broadcast by sender will be omitted
7892  */
7893 void AcceptChannel_set_dust_limit_satoshis(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
7894
7895 /**
7896  * The maximum inbound HTLC value in flight towards sender, in milli-satoshi
7897  */
7898 uint64_t AcceptChannel_get_max_htlc_value_in_flight_msat(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
7899
7900 /**
7901  * The maximum inbound HTLC value in flight towards sender, in milli-satoshi
7902  */
7903 void AcceptChannel_set_max_htlc_value_in_flight_msat(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
7904
7905 /**
7906  * The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
7907  */
7908 uint64_t AcceptChannel_get_channel_reserve_satoshis(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
7909
7910 /**
7911  * The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
7912  */
7913 void AcceptChannel_set_channel_reserve_satoshis(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
7914
7915 /**
7916  * The minimum HTLC size incoming to sender, in milli-satoshi
7917  */
7918 uint64_t AcceptChannel_get_htlc_minimum_msat(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
7919
7920 /**
7921  * The minimum HTLC size incoming to sender, in milli-satoshi
7922  */
7923 void AcceptChannel_set_htlc_minimum_msat(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
7924
7925 /**
7926  * Minimum depth of the funding transaction before the channel is considered open
7927  */
7928 uint32_t AcceptChannel_get_minimum_depth(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
7929
7930 /**
7931  * Minimum depth of the funding transaction before the channel is considered open
7932  */
7933 void AcceptChannel_set_minimum_depth(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint32_t val);
7934
7935 /**
7936  * The number of blocks which the counterparty will have to wait to claim on-chain funds if they broadcast a commitment transaction
7937  */
7938 uint16_t AcceptChannel_get_to_self_delay(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
7939
7940 /**
7941  * The number of blocks which the counterparty will have to wait to claim on-chain funds if they broadcast a commitment transaction
7942  */
7943 void AcceptChannel_set_to_self_delay(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint16_t val);
7944
7945 /**
7946  * The maximum number of inbound HTLCs towards sender
7947  */
7948 uint16_t AcceptChannel_get_max_accepted_htlcs(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
7949
7950 /**
7951  * The maximum number of inbound HTLCs towards sender
7952  */
7953 void AcceptChannel_set_max_accepted_htlcs(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint16_t val);
7954
7955 /**
7956  * The sender's key controlling the funding transaction
7957  */
7958 struct LDKPublicKey AcceptChannel_get_funding_pubkey(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
7959
7960 /**
7961  * The sender's key controlling the funding transaction
7962  */
7963 void AcceptChannel_set_funding_pubkey(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
7964
7965 /**
7966  * Used to derive a revocation key for transactions broadcast by counterparty
7967  */
7968 struct LDKPublicKey AcceptChannel_get_revocation_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
7969
7970 /**
7971  * Used to derive a revocation key for transactions broadcast by counterparty
7972  */
7973 void AcceptChannel_set_revocation_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
7974
7975 /**
7976  * A payment key to sender for transactions broadcast by counterparty
7977  */
7978 struct LDKPublicKey AcceptChannel_get_payment_point(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
7979
7980 /**
7981  * A payment key to sender for transactions broadcast by counterparty
7982  */
7983 void AcceptChannel_set_payment_point(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
7984
7985 /**
7986  * Used to derive a payment key to sender for transactions broadcast by sender
7987  */
7988 struct LDKPublicKey AcceptChannel_get_delayed_payment_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
7989
7990 /**
7991  * Used to derive a payment key to sender for transactions broadcast by sender
7992  */
7993 void AcceptChannel_set_delayed_payment_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
7994
7995 /**
7996  * Used to derive an HTLC payment key to sender for transactions broadcast by counterparty
7997  */
7998 struct LDKPublicKey AcceptChannel_get_htlc_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
7999
8000 /**
8001  * Used to derive an HTLC payment key to sender for transactions broadcast by counterparty
8002  */
8003 void AcceptChannel_set_htlc_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
8004
8005 /**
8006  * The first to-be-broadcast-by-sender transaction's per commitment point
8007  */
8008 struct LDKPublicKey AcceptChannel_get_first_per_commitment_point(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
8009
8010 /**
8011  * The first to-be-broadcast-by-sender transaction's per commitment point
8012  */
8013 void AcceptChannel_set_first_per_commitment_point(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
8014
8015 /**
8016  * Creates a copy of the AcceptChannel
8017  */
8018 struct LDKAcceptChannel AcceptChannel_clone(const struct LDKAcceptChannel *NONNULL_PTR orig);
8019
8020 /**
8021  * Frees any resources used by the FundingCreated, if is_owned is set and inner is non-NULL.
8022  */
8023 void FundingCreated_free(struct LDKFundingCreated this_obj);
8024
8025 /**
8026  * A temporary channel ID, until the funding is established
8027  */
8028 const uint8_t (*FundingCreated_get_temporary_channel_id(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
8029
8030 /**
8031  * A temporary channel ID, until the funding is established
8032  */
8033 void FundingCreated_set_temporary_channel_id(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
8034
8035 /**
8036  * The funding transaction ID
8037  */
8038 const uint8_t (*FundingCreated_get_funding_txid(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
8039
8040 /**
8041  * The funding transaction ID
8042  */
8043 void FundingCreated_set_funding_txid(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
8044
8045 /**
8046  * The specific output index funding this channel
8047  */
8048 uint16_t FundingCreated_get_funding_output_index(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
8049
8050 /**
8051  * The specific output index funding this channel
8052  */
8053 void FundingCreated_set_funding_output_index(struct LDKFundingCreated *NONNULL_PTR this_ptr, uint16_t val);
8054
8055 /**
8056  * The signature of the channel initiator (funder) on the funding transaction
8057  */
8058 struct LDKSignature FundingCreated_get_signature(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
8059
8060 /**
8061  * The signature of the channel initiator (funder) on the funding transaction
8062  */
8063 void FundingCreated_set_signature(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKSignature val);
8064
8065 /**
8066  * Constructs a new FundingCreated given each field
8067  */
8068 MUST_USE_RES struct LDKFundingCreated FundingCreated_new(struct LDKThirtyTwoBytes temporary_channel_id_arg, struct LDKThirtyTwoBytes funding_txid_arg, uint16_t funding_output_index_arg, struct LDKSignature signature_arg);
8069
8070 /**
8071  * Creates a copy of the FundingCreated
8072  */
8073 struct LDKFundingCreated FundingCreated_clone(const struct LDKFundingCreated *NONNULL_PTR orig);
8074
8075 /**
8076  * Frees any resources used by the FundingSigned, if is_owned is set and inner is non-NULL.
8077  */
8078 void FundingSigned_free(struct LDKFundingSigned this_obj);
8079
8080 /**
8081  * The channel ID
8082  */
8083 const uint8_t (*FundingSigned_get_channel_id(const struct LDKFundingSigned *NONNULL_PTR this_ptr))[32];
8084
8085 /**
8086  * The channel ID
8087  */
8088 void FundingSigned_set_channel_id(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
8089
8090 /**
8091  * The signature of the channel acceptor (fundee) on the funding transaction
8092  */
8093 struct LDKSignature FundingSigned_get_signature(const struct LDKFundingSigned *NONNULL_PTR this_ptr);
8094
8095 /**
8096  * The signature of the channel acceptor (fundee) on the funding transaction
8097  */
8098 void FundingSigned_set_signature(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
8099
8100 /**
8101  * Constructs a new FundingSigned given each field
8102  */
8103 MUST_USE_RES struct LDKFundingSigned FundingSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKSignature signature_arg);
8104
8105 /**
8106  * Creates a copy of the FundingSigned
8107  */
8108 struct LDKFundingSigned FundingSigned_clone(const struct LDKFundingSigned *NONNULL_PTR orig);
8109
8110 /**
8111  * Frees any resources used by the FundingLocked, if is_owned is set and inner is non-NULL.
8112  */
8113 void FundingLocked_free(struct LDKFundingLocked this_obj);
8114
8115 /**
8116  * The channel ID
8117  */
8118 const uint8_t (*FundingLocked_get_channel_id(const struct LDKFundingLocked *NONNULL_PTR this_ptr))[32];
8119
8120 /**
8121  * The channel ID
8122  */
8123 void FundingLocked_set_channel_id(struct LDKFundingLocked *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
8124
8125 /**
8126  * The per-commitment point of the second commitment transaction
8127  */
8128 struct LDKPublicKey FundingLocked_get_next_per_commitment_point(const struct LDKFundingLocked *NONNULL_PTR this_ptr);
8129
8130 /**
8131  * The per-commitment point of the second commitment transaction
8132  */
8133 void FundingLocked_set_next_per_commitment_point(struct LDKFundingLocked *NONNULL_PTR this_ptr, struct LDKPublicKey val);
8134
8135 /**
8136  * Constructs a new FundingLocked given each field
8137  */
8138 MUST_USE_RES struct LDKFundingLocked FundingLocked_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKPublicKey next_per_commitment_point_arg);
8139
8140 /**
8141  * Creates a copy of the FundingLocked
8142  */
8143 struct LDKFundingLocked FundingLocked_clone(const struct LDKFundingLocked *NONNULL_PTR orig);
8144
8145 /**
8146  * Frees any resources used by the Shutdown, if is_owned is set and inner is non-NULL.
8147  */
8148 void Shutdown_free(struct LDKShutdown this_obj);
8149
8150 /**
8151  * The channel ID
8152  */
8153 const uint8_t (*Shutdown_get_channel_id(const struct LDKShutdown *NONNULL_PTR this_ptr))[32];
8154
8155 /**
8156  * The channel ID
8157  */
8158 void Shutdown_set_channel_id(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
8159
8160 /**
8161  * The destination of this peer's funds on closing.
8162  * Must be in one of these forms: p2pkh, p2sh, p2wpkh, p2wsh.
8163  */
8164 struct LDKu8slice Shutdown_get_scriptpubkey(const struct LDKShutdown *NONNULL_PTR this_ptr);
8165
8166 /**
8167  * The destination of this peer's funds on closing.
8168  * Must be in one of these forms: p2pkh, p2sh, p2wpkh, p2wsh.
8169  */
8170 void Shutdown_set_scriptpubkey(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
8171
8172 /**
8173  * Constructs a new Shutdown given each field
8174  */
8175 MUST_USE_RES struct LDKShutdown Shutdown_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKCVec_u8Z scriptpubkey_arg);
8176
8177 /**
8178  * Creates a copy of the Shutdown
8179  */
8180 struct LDKShutdown Shutdown_clone(const struct LDKShutdown *NONNULL_PTR orig);
8181
8182 /**
8183  * Frees any resources used by the ClosingSigned, if is_owned is set and inner is non-NULL.
8184  */
8185 void ClosingSigned_free(struct LDKClosingSigned this_obj);
8186
8187 /**
8188  * The channel ID
8189  */
8190 const uint8_t (*ClosingSigned_get_channel_id(const struct LDKClosingSigned *NONNULL_PTR this_ptr))[32];
8191
8192 /**
8193  * The channel ID
8194  */
8195 void ClosingSigned_set_channel_id(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
8196
8197 /**
8198  * The proposed total fee for the closing transaction
8199  */
8200 uint64_t ClosingSigned_get_fee_satoshis(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
8201
8202 /**
8203  * The proposed total fee for the closing transaction
8204  */
8205 void ClosingSigned_set_fee_satoshis(struct LDKClosingSigned *NONNULL_PTR this_ptr, uint64_t val);
8206
8207 /**
8208  * A signature on the closing transaction
8209  */
8210 struct LDKSignature ClosingSigned_get_signature(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
8211
8212 /**
8213  * A signature on the closing transaction
8214  */
8215 void ClosingSigned_set_signature(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
8216
8217 /**
8218  * Constructs a new ClosingSigned given each field
8219  */
8220 MUST_USE_RES struct LDKClosingSigned ClosingSigned_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t fee_satoshis_arg, struct LDKSignature signature_arg);
8221
8222 /**
8223  * Creates a copy of the ClosingSigned
8224  */
8225 struct LDKClosingSigned ClosingSigned_clone(const struct LDKClosingSigned *NONNULL_PTR orig);
8226
8227 /**
8228  * Frees any resources used by the UpdateAddHTLC, if is_owned is set and inner is non-NULL.
8229  */
8230 void UpdateAddHTLC_free(struct LDKUpdateAddHTLC this_obj);
8231
8232 /**
8233  * The channel ID
8234  */
8235 const uint8_t (*UpdateAddHTLC_get_channel_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
8236
8237 /**
8238  * The channel ID
8239  */
8240 void UpdateAddHTLC_set_channel_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
8241
8242 /**
8243  * The HTLC ID
8244  */
8245 uint64_t UpdateAddHTLC_get_htlc_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
8246
8247 /**
8248  * The HTLC ID
8249  */
8250 void UpdateAddHTLC_set_htlc_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
8251
8252 /**
8253  * The HTLC value in milli-satoshi
8254  */
8255 uint64_t UpdateAddHTLC_get_amount_msat(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
8256
8257 /**
8258  * The HTLC value in milli-satoshi
8259  */
8260 void UpdateAddHTLC_set_amount_msat(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
8261
8262 /**
8263  * The payment hash, the pre-image of which controls HTLC redemption
8264  */
8265 const uint8_t (*UpdateAddHTLC_get_payment_hash(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
8266
8267 /**
8268  * The payment hash, the pre-image of which controls HTLC redemption
8269  */
8270 void UpdateAddHTLC_set_payment_hash(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
8271
8272 /**
8273  * The expiry height of the HTLC
8274  */
8275 uint32_t UpdateAddHTLC_get_cltv_expiry(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
8276
8277 /**
8278  * The expiry height of the HTLC
8279  */
8280 void UpdateAddHTLC_set_cltv_expiry(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint32_t val);
8281
8282 /**
8283  * Creates a copy of the UpdateAddHTLC
8284  */
8285 struct LDKUpdateAddHTLC UpdateAddHTLC_clone(const struct LDKUpdateAddHTLC *NONNULL_PTR orig);
8286
8287 /**
8288  * Frees any resources used by the UpdateFulfillHTLC, if is_owned is set and inner is non-NULL.
8289  */
8290 void UpdateFulfillHTLC_free(struct LDKUpdateFulfillHTLC this_obj);
8291
8292 /**
8293  * The channel ID
8294  */
8295 const uint8_t (*UpdateFulfillHTLC_get_channel_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
8296
8297 /**
8298  * The channel ID
8299  */
8300 void UpdateFulfillHTLC_set_channel_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
8301
8302 /**
8303  * The HTLC ID
8304  */
8305 uint64_t UpdateFulfillHTLC_get_htlc_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr);
8306
8307 /**
8308  * The HTLC ID
8309  */
8310 void UpdateFulfillHTLC_set_htlc_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, uint64_t val);
8311
8312 /**
8313  * The pre-image of the payment hash, allowing HTLC redemption
8314  */
8315 const uint8_t (*UpdateFulfillHTLC_get_payment_preimage(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
8316
8317 /**
8318  * The pre-image of the payment hash, allowing HTLC redemption
8319  */
8320 void UpdateFulfillHTLC_set_payment_preimage(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
8321
8322 /**
8323  * Constructs a new UpdateFulfillHTLC given each field
8324  */
8325 MUST_USE_RES struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t htlc_id_arg, struct LDKThirtyTwoBytes payment_preimage_arg);
8326
8327 /**
8328  * Creates a copy of the UpdateFulfillHTLC
8329  */
8330 struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_clone(const struct LDKUpdateFulfillHTLC *NONNULL_PTR orig);
8331
8332 /**
8333  * Frees any resources used by the UpdateFailHTLC, if is_owned is set and inner is non-NULL.
8334  */
8335 void UpdateFailHTLC_free(struct LDKUpdateFailHTLC this_obj);
8336
8337 /**
8338  * The channel ID
8339  */
8340 const uint8_t (*UpdateFailHTLC_get_channel_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr))[32];
8341
8342 /**
8343  * The channel ID
8344  */
8345 void UpdateFailHTLC_set_channel_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
8346
8347 /**
8348  * The HTLC ID
8349  */
8350 uint64_t UpdateFailHTLC_get_htlc_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr);
8351
8352 /**
8353  * The HTLC ID
8354  */
8355 void UpdateFailHTLC_set_htlc_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, uint64_t val);
8356
8357 /**
8358  * Creates a copy of the UpdateFailHTLC
8359  */
8360 struct LDKUpdateFailHTLC UpdateFailHTLC_clone(const struct LDKUpdateFailHTLC *NONNULL_PTR orig);
8361
8362 /**
8363  * Frees any resources used by the UpdateFailMalformedHTLC, if is_owned is set and inner is non-NULL.
8364  */
8365 void UpdateFailMalformedHTLC_free(struct LDKUpdateFailMalformedHTLC this_obj);
8366
8367 /**
8368  * The channel ID
8369  */
8370 const uint8_t (*UpdateFailMalformedHTLC_get_channel_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr))[32];
8371
8372 /**
8373  * The channel ID
8374  */
8375 void UpdateFailMalformedHTLC_set_channel_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
8376
8377 /**
8378  * The HTLC ID
8379  */
8380 uint64_t UpdateFailMalformedHTLC_get_htlc_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
8381
8382 /**
8383  * The HTLC ID
8384  */
8385 void UpdateFailMalformedHTLC_set_htlc_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint64_t val);
8386
8387 /**
8388  * The failure code
8389  */
8390 uint16_t UpdateFailMalformedHTLC_get_failure_code(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
8391
8392 /**
8393  * The failure code
8394  */
8395 void UpdateFailMalformedHTLC_set_failure_code(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint16_t val);
8396
8397 /**
8398  * Creates a copy of the UpdateFailMalformedHTLC
8399  */
8400 struct LDKUpdateFailMalformedHTLC UpdateFailMalformedHTLC_clone(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR orig);
8401
8402 /**
8403  * Frees any resources used by the CommitmentSigned, if is_owned is set and inner is non-NULL.
8404  */
8405 void CommitmentSigned_free(struct LDKCommitmentSigned this_obj);
8406
8407 /**
8408  * The channel ID
8409  */
8410 const uint8_t (*CommitmentSigned_get_channel_id(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr))[32];
8411
8412 /**
8413  * The channel ID
8414  */
8415 void CommitmentSigned_set_channel_id(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
8416
8417 /**
8418  * A signature on the commitment transaction
8419  */
8420 struct LDKSignature CommitmentSigned_get_signature(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr);
8421
8422 /**
8423  * A signature on the commitment transaction
8424  */
8425 void CommitmentSigned_set_signature(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
8426
8427 /**
8428  * Signatures on the HTLC transactions
8429  */
8430 void CommitmentSigned_set_htlc_signatures(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKCVec_SignatureZ val);
8431
8432 /**
8433  * Constructs a new CommitmentSigned given each field
8434  */
8435 MUST_USE_RES struct LDKCommitmentSigned CommitmentSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKSignature signature_arg, struct LDKCVec_SignatureZ htlc_signatures_arg);
8436
8437 /**
8438  * Creates a copy of the CommitmentSigned
8439  */
8440 struct LDKCommitmentSigned CommitmentSigned_clone(const struct LDKCommitmentSigned *NONNULL_PTR orig);
8441
8442 /**
8443  * Frees any resources used by the RevokeAndACK, if is_owned is set and inner is non-NULL.
8444  */
8445 void RevokeAndACK_free(struct LDKRevokeAndACK this_obj);
8446
8447 /**
8448  * The channel ID
8449  */
8450 const uint8_t (*RevokeAndACK_get_channel_id(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
8451
8452 /**
8453  * The channel ID
8454  */
8455 void RevokeAndACK_set_channel_id(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
8456
8457 /**
8458  * The secret corresponding to the per-commitment point
8459  */
8460 const uint8_t (*RevokeAndACK_get_per_commitment_secret(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
8461
8462 /**
8463  * The secret corresponding to the per-commitment point
8464  */
8465 void RevokeAndACK_set_per_commitment_secret(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
8466
8467 /**
8468  * The next sender-broadcast commitment transaction's per-commitment point
8469  */
8470 struct LDKPublicKey RevokeAndACK_get_next_per_commitment_point(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr);
8471
8472 /**
8473  * The next sender-broadcast commitment transaction's per-commitment point
8474  */
8475 void RevokeAndACK_set_next_per_commitment_point(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKPublicKey val);
8476
8477 /**
8478  * Constructs a new RevokeAndACK given each field
8479  */
8480 MUST_USE_RES struct LDKRevokeAndACK RevokeAndACK_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKThirtyTwoBytes per_commitment_secret_arg, struct LDKPublicKey next_per_commitment_point_arg);
8481
8482 /**
8483  * Creates a copy of the RevokeAndACK
8484  */
8485 struct LDKRevokeAndACK RevokeAndACK_clone(const struct LDKRevokeAndACK *NONNULL_PTR orig);
8486
8487 /**
8488  * Frees any resources used by the UpdateFee, if is_owned is set and inner is non-NULL.
8489  */
8490 void UpdateFee_free(struct LDKUpdateFee this_obj);
8491
8492 /**
8493  * The channel ID
8494  */
8495 const uint8_t (*UpdateFee_get_channel_id(const struct LDKUpdateFee *NONNULL_PTR this_ptr))[32];
8496
8497 /**
8498  * The channel ID
8499  */
8500 void UpdateFee_set_channel_id(struct LDKUpdateFee *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
8501
8502 /**
8503  * Fee rate per 1000-weight of the transaction
8504  */
8505 uint32_t UpdateFee_get_feerate_per_kw(const struct LDKUpdateFee *NONNULL_PTR this_ptr);
8506
8507 /**
8508  * Fee rate per 1000-weight of the transaction
8509  */
8510 void UpdateFee_set_feerate_per_kw(struct LDKUpdateFee *NONNULL_PTR this_ptr, uint32_t val);
8511
8512 /**
8513  * Constructs a new UpdateFee given each field
8514  */
8515 MUST_USE_RES struct LDKUpdateFee UpdateFee_new(struct LDKThirtyTwoBytes channel_id_arg, uint32_t feerate_per_kw_arg);
8516
8517 /**
8518  * Creates a copy of the UpdateFee
8519  */
8520 struct LDKUpdateFee UpdateFee_clone(const struct LDKUpdateFee *NONNULL_PTR orig);
8521
8522 /**
8523  * Frees any resources used by the DataLossProtect, if is_owned is set and inner is non-NULL.
8524  */
8525 void DataLossProtect_free(struct LDKDataLossProtect this_obj);
8526
8527 /**
8528  * Proof that the sender knows the per-commitment secret of a specific commitment transaction
8529  * belonging to the recipient
8530  */
8531 const uint8_t (*DataLossProtect_get_your_last_per_commitment_secret(const struct LDKDataLossProtect *NONNULL_PTR this_ptr))[32];
8532
8533 /**
8534  * Proof that the sender knows the per-commitment secret of a specific commitment transaction
8535  * belonging to the recipient
8536  */
8537 void DataLossProtect_set_your_last_per_commitment_secret(struct LDKDataLossProtect *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
8538
8539 /**
8540  * The sender's per-commitment point for their current commitment transaction
8541  */
8542 struct LDKPublicKey DataLossProtect_get_my_current_per_commitment_point(const struct LDKDataLossProtect *NONNULL_PTR this_ptr);
8543
8544 /**
8545  * The sender's per-commitment point for their current commitment transaction
8546  */
8547 void DataLossProtect_set_my_current_per_commitment_point(struct LDKDataLossProtect *NONNULL_PTR this_ptr, struct LDKPublicKey val);
8548
8549 /**
8550  * Constructs a new DataLossProtect given each field
8551  */
8552 MUST_USE_RES struct LDKDataLossProtect DataLossProtect_new(struct LDKThirtyTwoBytes your_last_per_commitment_secret_arg, struct LDKPublicKey my_current_per_commitment_point_arg);
8553
8554 /**
8555  * Creates a copy of the DataLossProtect
8556  */
8557 struct LDKDataLossProtect DataLossProtect_clone(const struct LDKDataLossProtect *NONNULL_PTR orig);
8558
8559 /**
8560  * Frees any resources used by the ChannelReestablish, if is_owned is set and inner is non-NULL.
8561  */
8562 void ChannelReestablish_free(struct LDKChannelReestablish this_obj);
8563
8564 /**
8565  * The channel ID
8566  */
8567 const uint8_t (*ChannelReestablish_get_channel_id(const struct LDKChannelReestablish *NONNULL_PTR this_ptr))[32];
8568
8569 /**
8570  * The channel ID
8571  */
8572 void ChannelReestablish_set_channel_id(struct LDKChannelReestablish *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
8573
8574 /**
8575  * The next commitment number for the sender
8576  */
8577 uint64_t ChannelReestablish_get_next_local_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
8578
8579 /**
8580  * The next commitment number for the sender
8581  */
8582 void ChannelReestablish_set_next_local_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
8583
8584 /**
8585  * The next commitment number for the recipient
8586  */
8587 uint64_t ChannelReestablish_get_next_remote_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
8588
8589 /**
8590  * The next commitment number for the recipient
8591  */
8592 void ChannelReestablish_set_next_remote_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
8593
8594 /**
8595  * Creates a copy of the ChannelReestablish
8596  */
8597 struct LDKChannelReestablish ChannelReestablish_clone(const struct LDKChannelReestablish *NONNULL_PTR orig);
8598
8599 /**
8600  * Frees any resources used by the AnnouncementSignatures, if is_owned is set and inner is non-NULL.
8601  */
8602 void AnnouncementSignatures_free(struct LDKAnnouncementSignatures this_obj);
8603
8604 /**
8605  * The channel ID
8606  */
8607 const uint8_t (*AnnouncementSignatures_get_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr))[32];
8608
8609 /**
8610  * The channel ID
8611  */
8612 void AnnouncementSignatures_set_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
8613
8614 /**
8615  * The short channel ID
8616  */
8617 uint64_t AnnouncementSignatures_get_short_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
8618
8619 /**
8620  * The short channel ID
8621  */
8622 void AnnouncementSignatures_set_short_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, uint64_t val);
8623
8624 /**
8625  * A signature by the node key
8626  */
8627 struct LDKSignature AnnouncementSignatures_get_node_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
8628
8629 /**
8630  * A signature by the node key
8631  */
8632 void AnnouncementSignatures_set_node_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKSignature val);
8633
8634 /**
8635  * A signature by the funding key
8636  */
8637 struct LDKSignature AnnouncementSignatures_get_bitcoin_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
8638
8639 /**
8640  * A signature by the funding key
8641  */
8642 void AnnouncementSignatures_set_bitcoin_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKSignature val);
8643
8644 /**
8645  * Constructs a new AnnouncementSignatures given each field
8646  */
8647 MUST_USE_RES struct LDKAnnouncementSignatures AnnouncementSignatures_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t short_channel_id_arg, struct LDKSignature node_signature_arg, struct LDKSignature bitcoin_signature_arg);
8648
8649 /**
8650  * Creates a copy of the AnnouncementSignatures
8651  */
8652 struct LDKAnnouncementSignatures AnnouncementSignatures_clone(const struct LDKAnnouncementSignatures *NONNULL_PTR orig);
8653
8654 /**
8655  * Frees any resources used by the NetAddress
8656  */
8657 void NetAddress_free(struct LDKNetAddress this_ptr);
8658
8659 /**
8660  * Creates a copy of the NetAddress
8661  */
8662 struct LDKNetAddress NetAddress_clone(const struct LDKNetAddress *NONNULL_PTR orig);
8663
8664 /**
8665  * Serialize the NetAddress object into a byte array which can be read by NetAddress_read
8666  */
8667 struct LDKCVec_u8Z NetAddress_write(const struct LDKNetAddress *NONNULL_PTR obj);
8668
8669 /**
8670  * Read a Result from a byte array, created by Result_write
8671  */
8672 struct LDKCResult_CResult_NetAddressu8ZDecodeErrorZ Result_read(struct LDKu8slice ser);
8673
8674 /**
8675  * Frees any resources used by the UnsignedNodeAnnouncement, if is_owned is set and inner is non-NULL.
8676  */
8677 void UnsignedNodeAnnouncement_free(struct LDKUnsignedNodeAnnouncement this_obj);
8678
8679 /**
8680  * The advertised features
8681  */
8682 struct LDKNodeFeatures UnsignedNodeAnnouncement_get_features(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
8683
8684 /**
8685  * The advertised features
8686  */
8687 void UnsignedNodeAnnouncement_set_features(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
8688
8689 /**
8690  * A strictly monotonic announcement counter, with gaps allowed
8691  */
8692 uint32_t UnsignedNodeAnnouncement_get_timestamp(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
8693
8694 /**
8695  * A strictly monotonic announcement counter, with gaps allowed
8696  */
8697 void UnsignedNodeAnnouncement_set_timestamp(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, uint32_t val);
8698
8699 /**
8700  * The node_id this announcement originated from (don't rebroadcast the node_announcement back
8701  * to this node).
8702  */
8703 struct LDKPublicKey UnsignedNodeAnnouncement_get_node_id(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
8704
8705 /**
8706  * The node_id this announcement originated from (don't rebroadcast the node_announcement back
8707  * to this node).
8708  */
8709 void UnsignedNodeAnnouncement_set_node_id(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
8710
8711 /**
8712  * An RGB color for UI purposes
8713  */
8714 const uint8_t (*UnsignedNodeAnnouncement_get_rgb(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr))[3];
8715
8716 /**
8717  * An RGB color for UI purposes
8718  */
8719 void UnsignedNodeAnnouncement_set_rgb(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
8720
8721 /**
8722  * An alias, for UI purposes.  This should be sanitized before use.  There is no guarantee
8723  * of uniqueness.
8724  */
8725 const uint8_t (*UnsignedNodeAnnouncement_get_alias(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr))[32];
8726
8727 /**
8728  * An alias, for UI purposes.  This should be sanitized before use.  There is no guarantee
8729  * of uniqueness.
8730  */
8731 void UnsignedNodeAnnouncement_set_alias(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
8732
8733 /**
8734  * List of addresses on which this node is reachable
8735  */
8736 void UnsignedNodeAnnouncement_set_addresses(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKCVec_NetAddressZ val);
8737
8738 /**
8739  * Creates a copy of the UnsignedNodeAnnouncement
8740  */
8741 struct LDKUnsignedNodeAnnouncement UnsignedNodeAnnouncement_clone(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR orig);
8742
8743 /**
8744  * Frees any resources used by the NodeAnnouncement, if is_owned is set and inner is non-NULL.
8745  */
8746 void NodeAnnouncement_free(struct LDKNodeAnnouncement this_obj);
8747
8748 /**
8749  * The signature by the node key
8750  */
8751 struct LDKSignature NodeAnnouncement_get_signature(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
8752
8753 /**
8754  * The signature by the node key
8755  */
8756 void NodeAnnouncement_set_signature(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
8757
8758 /**
8759  * The actual content of the announcement
8760  */
8761 struct LDKUnsignedNodeAnnouncement NodeAnnouncement_get_contents(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
8762
8763 /**
8764  * The actual content of the announcement
8765  */
8766 void NodeAnnouncement_set_contents(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedNodeAnnouncement val);
8767
8768 /**
8769  * Constructs a new NodeAnnouncement given each field
8770  */
8771 MUST_USE_RES struct LDKNodeAnnouncement NodeAnnouncement_new(struct LDKSignature signature_arg, struct LDKUnsignedNodeAnnouncement contents_arg);
8772
8773 /**
8774  * Creates a copy of the NodeAnnouncement
8775  */
8776 struct LDKNodeAnnouncement NodeAnnouncement_clone(const struct LDKNodeAnnouncement *NONNULL_PTR orig);
8777
8778 /**
8779  * Frees any resources used by the UnsignedChannelAnnouncement, if is_owned is set and inner is non-NULL.
8780  */
8781 void UnsignedChannelAnnouncement_free(struct LDKUnsignedChannelAnnouncement this_obj);
8782
8783 /**
8784  * The advertised channel features
8785  */
8786 struct LDKChannelFeatures UnsignedChannelAnnouncement_get_features(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
8787
8788 /**
8789  * The advertised channel features
8790  */
8791 void UnsignedChannelAnnouncement_set_features(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
8792
8793 /**
8794  * The genesis hash of the blockchain where the channel is to be opened
8795  */
8796 const uint8_t (*UnsignedChannelAnnouncement_get_chain_hash(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr))[32];
8797
8798 /**
8799  * The genesis hash of the blockchain where the channel is to be opened
8800  */
8801 void UnsignedChannelAnnouncement_set_chain_hash(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
8802
8803 /**
8804  * The short channel ID
8805  */
8806 uint64_t UnsignedChannelAnnouncement_get_short_channel_id(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
8807
8808 /**
8809  * The short channel ID
8810  */
8811 void UnsignedChannelAnnouncement_set_short_channel_id(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, uint64_t val);
8812
8813 /**
8814  * One of the two node_ids which are endpoints of this channel
8815  */
8816 struct LDKPublicKey UnsignedChannelAnnouncement_get_node_id_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
8817
8818 /**
8819  * One of the two node_ids which are endpoints of this channel
8820  */
8821 void UnsignedChannelAnnouncement_set_node_id_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
8822
8823 /**
8824  * The other of the two node_ids which are endpoints of this channel
8825  */
8826 struct LDKPublicKey UnsignedChannelAnnouncement_get_node_id_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
8827
8828 /**
8829  * The other of the two node_ids which are endpoints of this channel
8830  */
8831 void UnsignedChannelAnnouncement_set_node_id_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
8832
8833 /**
8834  * The funding key for the first node
8835  */
8836 struct LDKPublicKey UnsignedChannelAnnouncement_get_bitcoin_key_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
8837
8838 /**
8839  * The funding key for the first node
8840  */
8841 void UnsignedChannelAnnouncement_set_bitcoin_key_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
8842
8843 /**
8844  * The funding key for the second node
8845  */
8846 struct LDKPublicKey UnsignedChannelAnnouncement_get_bitcoin_key_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
8847
8848 /**
8849  * The funding key for the second node
8850  */
8851 void UnsignedChannelAnnouncement_set_bitcoin_key_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
8852
8853 /**
8854  * Creates a copy of the UnsignedChannelAnnouncement
8855  */
8856 struct LDKUnsignedChannelAnnouncement UnsignedChannelAnnouncement_clone(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR orig);
8857
8858 /**
8859  * Frees any resources used by the ChannelAnnouncement, if is_owned is set and inner is non-NULL.
8860  */
8861 void ChannelAnnouncement_free(struct LDKChannelAnnouncement this_obj);
8862
8863 /**
8864  * Authentication of the announcement by the first public node
8865  */
8866 struct LDKSignature ChannelAnnouncement_get_node_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
8867
8868 /**
8869  * Authentication of the announcement by the first public node
8870  */
8871 void ChannelAnnouncement_set_node_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
8872
8873 /**
8874  * Authentication of the announcement by the second public node
8875  */
8876 struct LDKSignature ChannelAnnouncement_get_node_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
8877
8878 /**
8879  * Authentication of the announcement by the second public node
8880  */
8881 void ChannelAnnouncement_set_node_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
8882
8883 /**
8884  * Proof of funding UTXO ownership by the first public node
8885  */
8886 struct LDKSignature ChannelAnnouncement_get_bitcoin_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
8887
8888 /**
8889  * Proof of funding UTXO ownership by the first public node
8890  */
8891 void ChannelAnnouncement_set_bitcoin_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
8892
8893 /**
8894  * Proof of funding UTXO ownership by the second public node
8895  */
8896 struct LDKSignature ChannelAnnouncement_get_bitcoin_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
8897
8898 /**
8899  * Proof of funding UTXO ownership by the second public node
8900  */
8901 void ChannelAnnouncement_set_bitcoin_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
8902
8903 /**
8904  * The actual announcement
8905  */
8906 struct LDKUnsignedChannelAnnouncement ChannelAnnouncement_get_contents(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
8907
8908 /**
8909  * The actual announcement
8910  */
8911 void ChannelAnnouncement_set_contents(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedChannelAnnouncement val);
8912
8913 /**
8914  * Constructs a new ChannelAnnouncement given each field
8915  */
8916 MUST_USE_RES struct LDKChannelAnnouncement ChannelAnnouncement_new(struct LDKSignature node_signature_1_arg, struct LDKSignature node_signature_2_arg, struct LDKSignature bitcoin_signature_1_arg, struct LDKSignature bitcoin_signature_2_arg, struct LDKUnsignedChannelAnnouncement contents_arg);
8917
8918 /**
8919  * Creates a copy of the ChannelAnnouncement
8920  */
8921 struct LDKChannelAnnouncement ChannelAnnouncement_clone(const struct LDKChannelAnnouncement *NONNULL_PTR orig);
8922
8923 /**
8924  * Frees any resources used by the UnsignedChannelUpdate, if is_owned is set and inner is non-NULL.
8925  */
8926 void UnsignedChannelUpdate_free(struct LDKUnsignedChannelUpdate this_obj);
8927
8928 /**
8929  * The genesis hash of the blockchain where the channel is to be opened
8930  */
8931 const uint8_t (*UnsignedChannelUpdate_get_chain_hash(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr))[32];
8932
8933 /**
8934  * The genesis hash of the blockchain where the channel is to be opened
8935  */
8936 void UnsignedChannelUpdate_set_chain_hash(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
8937
8938 /**
8939  * The short channel ID
8940  */
8941 uint64_t UnsignedChannelUpdate_get_short_channel_id(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
8942
8943 /**
8944  * The short channel ID
8945  */
8946 void UnsignedChannelUpdate_set_short_channel_id(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
8947
8948 /**
8949  * A strictly monotonic announcement counter, with gaps allowed, specific to this channel
8950  */
8951 uint32_t UnsignedChannelUpdate_get_timestamp(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
8952
8953 /**
8954  * A strictly monotonic announcement counter, with gaps allowed, specific to this channel
8955  */
8956 void UnsignedChannelUpdate_set_timestamp(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
8957
8958 /**
8959  * Channel flags
8960  */
8961 uint8_t UnsignedChannelUpdate_get_flags(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
8962
8963 /**
8964  * Channel flags
8965  */
8966 void UnsignedChannelUpdate_set_flags(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint8_t val);
8967
8968 /**
8969  * The number of blocks such that if:
8970  * `incoming_htlc.cltv_expiry < outgoing_htlc.cltv_expiry + cltv_expiry_delta`
8971  * then we need to fail the HTLC backwards. When forwarding an HTLC, cltv_expiry_delta determines
8972  * the outgoing HTLC's minimum cltv_expiry value -- so, if an incoming HTLC comes in with a
8973  * cltv_expiry of 100000, and the node we're forwarding to has a cltv_expiry_delta value of 10,
8974  * then we'll check that the outgoing HTLC's cltv_expiry value is at least 100010 before
8975  * forwarding. Note that the HTLC sender is the one who originally sets this value when
8976  * constructing the route.
8977  */
8978 uint16_t UnsignedChannelUpdate_get_cltv_expiry_delta(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
8979
8980 /**
8981  * The number of blocks such that if:
8982  * `incoming_htlc.cltv_expiry < outgoing_htlc.cltv_expiry + cltv_expiry_delta`
8983  * then we need to fail the HTLC backwards. When forwarding an HTLC, cltv_expiry_delta determines
8984  * the outgoing HTLC's minimum cltv_expiry value -- so, if an incoming HTLC comes in with a
8985  * cltv_expiry of 100000, and the node we're forwarding to has a cltv_expiry_delta value of 10,
8986  * then we'll check that the outgoing HTLC's cltv_expiry value is at least 100010 before
8987  * forwarding. Note that the HTLC sender is the one who originally sets this value when
8988  * constructing the route.
8989  */
8990 void UnsignedChannelUpdate_set_cltv_expiry_delta(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint16_t val);
8991
8992 /**
8993  * The minimum HTLC size incoming to sender, in milli-satoshi
8994  */
8995 uint64_t UnsignedChannelUpdate_get_htlc_minimum_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
8996
8997 /**
8998  * The minimum HTLC size incoming to sender, in milli-satoshi
8999  */
9000 void UnsignedChannelUpdate_set_htlc_minimum_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
9001
9002 /**
9003  * The base HTLC fee charged by sender, in milli-satoshi
9004  */
9005 uint32_t UnsignedChannelUpdate_get_fee_base_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
9006
9007 /**
9008  * The base HTLC fee charged by sender, in milli-satoshi
9009  */
9010 void UnsignedChannelUpdate_set_fee_base_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
9011
9012 /**
9013  * The amount to fee multiplier, in micro-satoshi
9014  */
9015 uint32_t UnsignedChannelUpdate_get_fee_proportional_millionths(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
9016
9017 /**
9018  * The amount to fee multiplier, in micro-satoshi
9019  */
9020 void UnsignedChannelUpdate_set_fee_proportional_millionths(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
9021
9022 /**
9023  * Creates a copy of the UnsignedChannelUpdate
9024  */
9025 struct LDKUnsignedChannelUpdate UnsignedChannelUpdate_clone(const struct LDKUnsignedChannelUpdate *NONNULL_PTR orig);
9026
9027 /**
9028  * Frees any resources used by the ChannelUpdate, if is_owned is set and inner is non-NULL.
9029  */
9030 void ChannelUpdate_free(struct LDKChannelUpdate this_obj);
9031
9032 /**
9033  * A signature of the channel update
9034  */
9035 struct LDKSignature ChannelUpdate_get_signature(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
9036
9037 /**
9038  * A signature of the channel update
9039  */
9040 void ChannelUpdate_set_signature(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKSignature val);
9041
9042 /**
9043  * The actual channel update
9044  */
9045 struct LDKUnsignedChannelUpdate ChannelUpdate_get_contents(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
9046
9047 /**
9048  * The actual channel update
9049  */
9050 void ChannelUpdate_set_contents(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKUnsignedChannelUpdate val);
9051
9052 /**
9053  * Constructs a new ChannelUpdate given each field
9054  */
9055 MUST_USE_RES struct LDKChannelUpdate ChannelUpdate_new(struct LDKSignature signature_arg, struct LDKUnsignedChannelUpdate contents_arg);
9056
9057 /**
9058  * Creates a copy of the ChannelUpdate
9059  */
9060 struct LDKChannelUpdate ChannelUpdate_clone(const struct LDKChannelUpdate *NONNULL_PTR orig);
9061
9062 /**
9063  * Frees any resources used by the QueryChannelRange, if is_owned is set and inner is non-NULL.
9064  */
9065 void QueryChannelRange_free(struct LDKQueryChannelRange this_obj);
9066
9067 /**
9068  * The genesis hash of the blockchain being queried
9069  */
9070 const uint8_t (*QueryChannelRange_get_chain_hash(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr))[32];
9071
9072 /**
9073  * The genesis hash of the blockchain being queried
9074  */
9075 void QueryChannelRange_set_chain_hash(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
9076
9077 /**
9078  * The height of the first block for the channel UTXOs being queried
9079  */
9080 uint32_t QueryChannelRange_get_first_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
9081
9082 /**
9083  * The height of the first block for the channel UTXOs being queried
9084  */
9085 void QueryChannelRange_set_first_blocknum(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
9086
9087 /**
9088  * The number of blocks to include in the query results
9089  */
9090 uint32_t QueryChannelRange_get_number_of_blocks(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
9091
9092 /**
9093  * The number of blocks to include in the query results
9094  */
9095 void QueryChannelRange_set_number_of_blocks(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
9096
9097 /**
9098  * Constructs a new QueryChannelRange given each field
9099  */
9100 MUST_USE_RES struct LDKQueryChannelRange QueryChannelRange_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_blocknum_arg, uint32_t number_of_blocks_arg);
9101
9102 /**
9103  * Creates a copy of the QueryChannelRange
9104  */
9105 struct LDKQueryChannelRange QueryChannelRange_clone(const struct LDKQueryChannelRange *NONNULL_PTR orig);
9106
9107 /**
9108  * Frees any resources used by the ReplyChannelRange, if is_owned is set and inner is non-NULL.
9109  */
9110 void ReplyChannelRange_free(struct LDKReplyChannelRange this_obj);
9111
9112 /**
9113  * The genesis hash of the blockchain being queried
9114  */
9115 const uint8_t (*ReplyChannelRange_get_chain_hash(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr))[32];
9116
9117 /**
9118  * The genesis hash of the blockchain being queried
9119  */
9120 void ReplyChannelRange_set_chain_hash(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
9121
9122 /**
9123  * The height of the first block in the range of the reply
9124  */
9125 uint32_t ReplyChannelRange_get_first_blocknum(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
9126
9127 /**
9128  * The height of the first block in the range of the reply
9129  */
9130 void ReplyChannelRange_set_first_blocknum(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
9131
9132 /**
9133  * The number of blocks included in the range of the reply
9134  */
9135 uint32_t ReplyChannelRange_get_number_of_blocks(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
9136
9137 /**
9138  * The number of blocks included in the range of the reply
9139  */
9140 void ReplyChannelRange_set_number_of_blocks(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
9141
9142 /**
9143  * True when this is the final reply for a query
9144  */
9145 bool ReplyChannelRange_get_sync_complete(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
9146
9147 /**
9148  * True when this is the final reply for a query
9149  */
9150 void ReplyChannelRange_set_sync_complete(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, bool val);
9151
9152 /**
9153  * The short_channel_ids in the channel range
9154  */
9155 void ReplyChannelRange_set_short_channel_ids(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
9156
9157 /**
9158  * Constructs a new ReplyChannelRange given each field
9159  */
9160 MUST_USE_RES struct LDKReplyChannelRange ReplyChannelRange_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_blocknum_arg, uint32_t number_of_blocks_arg, bool sync_complete_arg, struct LDKCVec_u64Z short_channel_ids_arg);
9161
9162 /**
9163  * Creates a copy of the ReplyChannelRange
9164  */
9165 struct LDKReplyChannelRange ReplyChannelRange_clone(const struct LDKReplyChannelRange *NONNULL_PTR orig);
9166
9167 /**
9168  * Frees any resources used by the QueryShortChannelIds, if is_owned is set and inner is non-NULL.
9169  */
9170 void QueryShortChannelIds_free(struct LDKQueryShortChannelIds this_obj);
9171
9172 /**
9173  * The genesis hash of the blockchain being queried
9174  */
9175 const uint8_t (*QueryShortChannelIds_get_chain_hash(const struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr))[32];
9176
9177 /**
9178  * The genesis hash of the blockchain being queried
9179  */
9180 void QueryShortChannelIds_set_chain_hash(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
9181
9182 /**
9183  * The short_channel_ids that are being queried
9184  */
9185 void QueryShortChannelIds_set_short_channel_ids(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
9186
9187 /**
9188  * Constructs a new QueryShortChannelIds given each field
9189  */
9190 MUST_USE_RES struct LDKQueryShortChannelIds QueryShortChannelIds_new(struct LDKThirtyTwoBytes chain_hash_arg, struct LDKCVec_u64Z short_channel_ids_arg);
9191
9192 /**
9193  * Creates a copy of the QueryShortChannelIds
9194  */
9195 struct LDKQueryShortChannelIds QueryShortChannelIds_clone(const struct LDKQueryShortChannelIds *NONNULL_PTR orig);
9196
9197 /**
9198  * Frees any resources used by the ReplyShortChannelIdsEnd, if is_owned is set and inner is non-NULL.
9199  */
9200 void ReplyShortChannelIdsEnd_free(struct LDKReplyShortChannelIdsEnd this_obj);
9201
9202 /**
9203  * The genesis hash of the blockchain that was queried
9204  */
9205 const uint8_t (*ReplyShortChannelIdsEnd_get_chain_hash(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr))[32];
9206
9207 /**
9208  * The genesis hash of the blockchain that was queried
9209  */
9210 void ReplyShortChannelIdsEnd_set_chain_hash(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
9211
9212 /**
9213  * Indicates if the query recipient maintains up-to-date channel
9214  * information for the chain_hash
9215  */
9216 bool ReplyShortChannelIdsEnd_get_full_information(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr);
9217
9218 /**
9219  * Indicates if the query recipient maintains up-to-date channel
9220  * information for the chain_hash
9221  */
9222 void ReplyShortChannelIdsEnd_set_full_information(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, bool val);
9223
9224 /**
9225  * Constructs a new ReplyShortChannelIdsEnd given each field
9226  */
9227 MUST_USE_RES struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_new(struct LDKThirtyTwoBytes chain_hash_arg, bool full_information_arg);
9228
9229 /**
9230  * Creates a copy of the ReplyShortChannelIdsEnd
9231  */
9232 struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_clone(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR orig);
9233
9234 /**
9235  * Frees any resources used by the GossipTimestampFilter, if is_owned is set and inner is non-NULL.
9236  */
9237 void GossipTimestampFilter_free(struct LDKGossipTimestampFilter this_obj);
9238
9239 /**
9240  * The genesis hash of the blockchain for channel and node information
9241  */
9242 const uint8_t (*GossipTimestampFilter_get_chain_hash(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr))[32];
9243
9244 /**
9245  * The genesis hash of the blockchain for channel and node information
9246  */
9247 void GossipTimestampFilter_set_chain_hash(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
9248
9249 /**
9250  * The starting unix timestamp
9251  */
9252 uint32_t GossipTimestampFilter_get_first_timestamp(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
9253
9254 /**
9255  * The starting unix timestamp
9256  */
9257 void GossipTimestampFilter_set_first_timestamp(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
9258
9259 /**
9260  * The range of information in seconds
9261  */
9262 uint32_t GossipTimestampFilter_get_timestamp_range(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
9263
9264 /**
9265  * The range of information in seconds
9266  */
9267 void GossipTimestampFilter_set_timestamp_range(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
9268
9269 /**
9270  * Constructs a new GossipTimestampFilter given each field
9271  */
9272 MUST_USE_RES struct LDKGossipTimestampFilter GossipTimestampFilter_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_timestamp_arg, uint32_t timestamp_range_arg);
9273
9274 /**
9275  * Creates a copy of the GossipTimestampFilter
9276  */
9277 struct LDKGossipTimestampFilter GossipTimestampFilter_clone(const struct LDKGossipTimestampFilter *NONNULL_PTR orig);
9278
9279 /**
9280  * Frees any resources used by the ErrorAction
9281  */
9282 void ErrorAction_free(struct LDKErrorAction this_ptr);
9283
9284 /**
9285  * Creates a copy of the ErrorAction
9286  */
9287 struct LDKErrorAction ErrorAction_clone(const struct LDKErrorAction *NONNULL_PTR orig);
9288
9289 /**
9290  * Frees any resources used by the LightningError, if is_owned is set and inner is non-NULL.
9291  */
9292 void LightningError_free(struct LDKLightningError this_obj);
9293
9294 /**
9295  * A human-readable message describing the error
9296  */
9297 struct LDKStr LightningError_get_err(const struct LDKLightningError *NONNULL_PTR this_ptr);
9298
9299 /**
9300  * A human-readable message describing the error
9301  */
9302 void LightningError_set_err(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
9303
9304 /**
9305  * The action which should be taken against the offending peer.
9306  */
9307 struct LDKErrorAction LightningError_get_action(const struct LDKLightningError *NONNULL_PTR this_ptr);
9308
9309 /**
9310  * The action which should be taken against the offending peer.
9311  */
9312 void LightningError_set_action(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKErrorAction val);
9313
9314 /**
9315  * Constructs a new LightningError given each field
9316  */
9317 MUST_USE_RES struct LDKLightningError LightningError_new(struct LDKCVec_u8Z err_arg, struct LDKErrorAction action_arg);
9318
9319 /**
9320  * Creates a copy of the LightningError
9321  */
9322 struct LDKLightningError LightningError_clone(const struct LDKLightningError *NONNULL_PTR orig);
9323
9324 /**
9325  * Frees any resources used by the CommitmentUpdate, if is_owned is set and inner is non-NULL.
9326  */
9327 void CommitmentUpdate_free(struct LDKCommitmentUpdate this_obj);
9328
9329 /**
9330  * update_add_htlc messages which should be sent
9331  */
9332 void CommitmentUpdate_set_update_add_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateAddHTLCZ val);
9333
9334 /**
9335  * update_fulfill_htlc messages which should be sent
9336  */
9337 void CommitmentUpdate_set_update_fulfill_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFulfillHTLCZ val);
9338
9339 /**
9340  * update_fail_htlc messages which should be sent
9341  */
9342 void CommitmentUpdate_set_update_fail_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailHTLCZ val);
9343
9344 /**
9345  * update_fail_malformed_htlc messages which should be sent
9346  */
9347 void CommitmentUpdate_set_update_fail_malformed_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailMalformedHTLCZ val);
9348
9349 /**
9350  * An update_fee message which should be sent
9351  */
9352 struct LDKUpdateFee CommitmentUpdate_get_update_fee(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
9353
9354 /**
9355  * An update_fee message which should be sent
9356  */
9357 void CommitmentUpdate_set_update_fee(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKUpdateFee val);
9358
9359 /**
9360  * Finally, the commitment_signed message which should be sent
9361  */
9362 struct LDKCommitmentSigned CommitmentUpdate_get_commitment_signed(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
9363
9364 /**
9365  * Finally, the commitment_signed message which should be sent
9366  */
9367 void CommitmentUpdate_set_commitment_signed(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCommitmentSigned val);
9368
9369 /**
9370  * Constructs a new CommitmentUpdate given each field
9371  */
9372 MUST_USE_RES struct LDKCommitmentUpdate CommitmentUpdate_new(struct LDKCVec_UpdateAddHTLCZ update_add_htlcs_arg, struct LDKCVec_UpdateFulfillHTLCZ update_fulfill_htlcs_arg, struct LDKCVec_UpdateFailHTLCZ update_fail_htlcs_arg, struct LDKCVec_UpdateFailMalformedHTLCZ update_fail_malformed_htlcs_arg, struct LDKUpdateFee update_fee_arg, struct LDKCommitmentSigned commitment_signed_arg);
9373
9374 /**
9375  * Creates a copy of the CommitmentUpdate
9376  */
9377 struct LDKCommitmentUpdate CommitmentUpdate_clone(const struct LDKCommitmentUpdate *NONNULL_PTR orig);
9378
9379 /**
9380  * Frees any resources used by the HTLCFailChannelUpdate
9381  */
9382 void HTLCFailChannelUpdate_free(struct LDKHTLCFailChannelUpdate this_ptr);
9383
9384 /**
9385  * Creates a copy of the HTLCFailChannelUpdate
9386  */
9387 struct LDKHTLCFailChannelUpdate HTLCFailChannelUpdate_clone(const struct LDKHTLCFailChannelUpdate *NONNULL_PTR orig);
9388
9389 /**
9390  * Calls the free function if one is set
9391  */
9392 void ChannelMessageHandler_free(struct LDKChannelMessageHandler this_ptr);
9393
9394 /**
9395  * Calls the free function if one is set
9396  */
9397 void RoutingMessageHandler_free(struct LDKRoutingMessageHandler this_ptr);
9398
9399 /**
9400  * Serialize the AcceptChannel object into a byte array which can be read by AcceptChannel_read
9401  */
9402 struct LDKCVec_u8Z AcceptChannel_write(const struct LDKAcceptChannel *NONNULL_PTR obj);
9403
9404 /**
9405  * Read a AcceptChannel from a byte array, created by AcceptChannel_write
9406  */
9407 struct LDKCResult_AcceptChannelDecodeErrorZ AcceptChannel_read(struct LDKu8slice ser);
9408
9409 /**
9410  * Serialize the AnnouncementSignatures object into a byte array which can be read by AnnouncementSignatures_read
9411  */
9412 struct LDKCVec_u8Z AnnouncementSignatures_write(const struct LDKAnnouncementSignatures *NONNULL_PTR obj);
9413
9414 /**
9415  * Read a AnnouncementSignatures from a byte array, created by AnnouncementSignatures_write
9416  */
9417 struct LDKCResult_AnnouncementSignaturesDecodeErrorZ AnnouncementSignatures_read(struct LDKu8slice ser);
9418
9419 /**
9420  * Serialize the ChannelReestablish object into a byte array which can be read by ChannelReestablish_read
9421  */
9422 struct LDKCVec_u8Z ChannelReestablish_write(const struct LDKChannelReestablish *NONNULL_PTR obj);
9423
9424 /**
9425  * Read a ChannelReestablish from a byte array, created by ChannelReestablish_write
9426  */
9427 struct LDKCResult_ChannelReestablishDecodeErrorZ ChannelReestablish_read(struct LDKu8slice ser);
9428
9429 /**
9430  * Serialize the ClosingSigned object into a byte array which can be read by ClosingSigned_read
9431  */
9432 struct LDKCVec_u8Z ClosingSigned_write(const struct LDKClosingSigned *NONNULL_PTR obj);
9433
9434 /**
9435  * Read a ClosingSigned from a byte array, created by ClosingSigned_write
9436  */
9437 struct LDKCResult_ClosingSignedDecodeErrorZ ClosingSigned_read(struct LDKu8slice ser);
9438
9439 /**
9440  * Serialize the CommitmentSigned object into a byte array which can be read by CommitmentSigned_read
9441  */
9442 struct LDKCVec_u8Z CommitmentSigned_write(const struct LDKCommitmentSigned *NONNULL_PTR obj);
9443
9444 /**
9445  * Read a CommitmentSigned from a byte array, created by CommitmentSigned_write
9446  */
9447 struct LDKCResult_CommitmentSignedDecodeErrorZ CommitmentSigned_read(struct LDKu8slice ser);
9448
9449 /**
9450  * Serialize the FundingCreated object into a byte array which can be read by FundingCreated_read
9451  */
9452 struct LDKCVec_u8Z FundingCreated_write(const struct LDKFundingCreated *NONNULL_PTR obj);
9453
9454 /**
9455  * Read a FundingCreated from a byte array, created by FundingCreated_write
9456  */
9457 struct LDKCResult_FundingCreatedDecodeErrorZ FundingCreated_read(struct LDKu8slice ser);
9458
9459 /**
9460  * Serialize the FundingSigned object into a byte array which can be read by FundingSigned_read
9461  */
9462 struct LDKCVec_u8Z FundingSigned_write(const struct LDKFundingSigned *NONNULL_PTR obj);
9463
9464 /**
9465  * Read a FundingSigned from a byte array, created by FundingSigned_write
9466  */
9467 struct LDKCResult_FundingSignedDecodeErrorZ FundingSigned_read(struct LDKu8slice ser);
9468
9469 /**
9470  * Serialize the FundingLocked object into a byte array which can be read by FundingLocked_read
9471  */
9472 struct LDKCVec_u8Z FundingLocked_write(const struct LDKFundingLocked *NONNULL_PTR obj);
9473
9474 /**
9475  * Read a FundingLocked from a byte array, created by FundingLocked_write
9476  */
9477 struct LDKCResult_FundingLockedDecodeErrorZ FundingLocked_read(struct LDKu8slice ser);
9478
9479 /**
9480  * Serialize the Init object into a byte array which can be read by Init_read
9481  */
9482 struct LDKCVec_u8Z Init_write(const struct LDKInit *NONNULL_PTR obj);
9483
9484 /**
9485  * Read a Init from a byte array, created by Init_write
9486  */
9487 struct LDKCResult_InitDecodeErrorZ Init_read(struct LDKu8slice ser);
9488
9489 /**
9490  * Serialize the OpenChannel object into a byte array which can be read by OpenChannel_read
9491  */
9492 struct LDKCVec_u8Z OpenChannel_write(const struct LDKOpenChannel *NONNULL_PTR obj);
9493
9494 /**
9495  * Read a OpenChannel from a byte array, created by OpenChannel_write
9496  */
9497 struct LDKCResult_OpenChannelDecodeErrorZ OpenChannel_read(struct LDKu8slice ser);
9498
9499 /**
9500  * Serialize the RevokeAndACK object into a byte array which can be read by RevokeAndACK_read
9501  */
9502 struct LDKCVec_u8Z RevokeAndACK_write(const struct LDKRevokeAndACK *NONNULL_PTR obj);
9503
9504 /**
9505  * Read a RevokeAndACK from a byte array, created by RevokeAndACK_write
9506  */
9507 struct LDKCResult_RevokeAndACKDecodeErrorZ RevokeAndACK_read(struct LDKu8slice ser);
9508
9509 /**
9510  * Serialize the Shutdown object into a byte array which can be read by Shutdown_read
9511  */
9512 struct LDKCVec_u8Z Shutdown_write(const struct LDKShutdown *NONNULL_PTR obj);
9513
9514 /**
9515  * Read a Shutdown from a byte array, created by Shutdown_write
9516  */
9517 struct LDKCResult_ShutdownDecodeErrorZ Shutdown_read(struct LDKu8slice ser);
9518
9519 /**
9520  * Serialize the UpdateFailHTLC object into a byte array which can be read by UpdateFailHTLC_read
9521  */
9522 struct LDKCVec_u8Z UpdateFailHTLC_write(const struct LDKUpdateFailHTLC *NONNULL_PTR obj);
9523
9524 /**
9525  * Read a UpdateFailHTLC from a byte array, created by UpdateFailHTLC_write
9526  */
9527 struct LDKCResult_UpdateFailHTLCDecodeErrorZ UpdateFailHTLC_read(struct LDKu8slice ser);
9528
9529 /**
9530  * Serialize the UpdateFailMalformedHTLC object into a byte array which can be read by UpdateFailMalformedHTLC_read
9531  */
9532 struct LDKCVec_u8Z UpdateFailMalformedHTLC_write(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR obj);
9533
9534 /**
9535  * Read a UpdateFailMalformedHTLC from a byte array, created by UpdateFailMalformedHTLC_write
9536  */
9537 struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ UpdateFailMalformedHTLC_read(struct LDKu8slice ser);
9538
9539 /**
9540  * Serialize the UpdateFee object into a byte array which can be read by UpdateFee_read
9541  */
9542 struct LDKCVec_u8Z UpdateFee_write(const struct LDKUpdateFee *NONNULL_PTR obj);
9543
9544 /**
9545  * Read a UpdateFee from a byte array, created by UpdateFee_write
9546  */
9547 struct LDKCResult_UpdateFeeDecodeErrorZ UpdateFee_read(struct LDKu8slice ser);
9548
9549 /**
9550  * Serialize the UpdateFulfillHTLC object into a byte array which can be read by UpdateFulfillHTLC_read
9551  */
9552 struct LDKCVec_u8Z UpdateFulfillHTLC_write(const struct LDKUpdateFulfillHTLC *NONNULL_PTR obj);
9553
9554 /**
9555  * Read a UpdateFulfillHTLC from a byte array, created by UpdateFulfillHTLC_write
9556  */
9557 struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ UpdateFulfillHTLC_read(struct LDKu8slice ser);
9558
9559 /**
9560  * Serialize the UpdateAddHTLC object into a byte array which can be read by UpdateAddHTLC_read
9561  */
9562 struct LDKCVec_u8Z UpdateAddHTLC_write(const struct LDKUpdateAddHTLC *NONNULL_PTR obj);
9563
9564 /**
9565  * Read a UpdateAddHTLC from a byte array, created by UpdateAddHTLC_write
9566  */
9567 struct LDKCResult_UpdateAddHTLCDecodeErrorZ UpdateAddHTLC_read(struct LDKu8slice ser);
9568
9569 /**
9570  * Serialize the Ping object into a byte array which can be read by Ping_read
9571  */
9572 struct LDKCVec_u8Z Ping_write(const struct LDKPing *NONNULL_PTR obj);
9573
9574 /**
9575  * Read a Ping from a byte array, created by Ping_write
9576  */
9577 struct LDKCResult_PingDecodeErrorZ Ping_read(struct LDKu8slice ser);
9578
9579 /**
9580  * Serialize the Pong object into a byte array which can be read by Pong_read
9581  */
9582 struct LDKCVec_u8Z Pong_write(const struct LDKPong *NONNULL_PTR obj);
9583
9584 /**
9585  * Read a Pong from a byte array, created by Pong_write
9586  */
9587 struct LDKCResult_PongDecodeErrorZ Pong_read(struct LDKu8slice ser);
9588
9589 /**
9590  * Serialize the UnsignedChannelAnnouncement object into a byte array which can be read by UnsignedChannelAnnouncement_read
9591  */
9592 struct LDKCVec_u8Z UnsignedChannelAnnouncement_write(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR obj);
9593
9594 /**
9595  * Read a UnsignedChannelAnnouncement from a byte array, created by UnsignedChannelAnnouncement_write
9596  */
9597 struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ UnsignedChannelAnnouncement_read(struct LDKu8slice ser);
9598
9599 /**
9600  * Serialize the ChannelAnnouncement object into a byte array which can be read by ChannelAnnouncement_read
9601  */
9602 struct LDKCVec_u8Z ChannelAnnouncement_write(const struct LDKChannelAnnouncement *NONNULL_PTR obj);
9603
9604 /**
9605  * Read a ChannelAnnouncement from a byte array, created by ChannelAnnouncement_write
9606  */
9607 struct LDKCResult_ChannelAnnouncementDecodeErrorZ ChannelAnnouncement_read(struct LDKu8slice ser);
9608
9609 /**
9610  * Serialize the UnsignedChannelUpdate object into a byte array which can be read by UnsignedChannelUpdate_read
9611  */
9612 struct LDKCVec_u8Z UnsignedChannelUpdate_write(const struct LDKUnsignedChannelUpdate *NONNULL_PTR obj);
9613
9614 /**
9615  * Read a UnsignedChannelUpdate from a byte array, created by UnsignedChannelUpdate_write
9616  */
9617 struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ UnsignedChannelUpdate_read(struct LDKu8slice ser);
9618
9619 /**
9620  * Serialize the ChannelUpdate object into a byte array which can be read by ChannelUpdate_read
9621  */
9622 struct LDKCVec_u8Z ChannelUpdate_write(const struct LDKChannelUpdate *NONNULL_PTR obj);
9623
9624 /**
9625  * Read a ChannelUpdate from a byte array, created by ChannelUpdate_write
9626  */
9627 struct LDKCResult_ChannelUpdateDecodeErrorZ ChannelUpdate_read(struct LDKu8slice ser);
9628
9629 /**
9630  * Serialize the ErrorMessage object into a byte array which can be read by ErrorMessage_read
9631  */
9632 struct LDKCVec_u8Z ErrorMessage_write(const struct LDKErrorMessage *NONNULL_PTR obj);
9633
9634 /**
9635  * Read a ErrorMessage from a byte array, created by ErrorMessage_write
9636  */
9637 struct LDKCResult_ErrorMessageDecodeErrorZ ErrorMessage_read(struct LDKu8slice ser);
9638
9639 /**
9640  * Serialize the UnsignedNodeAnnouncement object into a byte array which can be read by UnsignedNodeAnnouncement_read
9641  */
9642 struct LDKCVec_u8Z UnsignedNodeAnnouncement_write(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR obj);
9643
9644 /**
9645  * Read a UnsignedNodeAnnouncement from a byte array, created by UnsignedNodeAnnouncement_write
9646  */
9647 struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ UnsignedNodeAnnouncement_read(struct LDKu8slice ser);
9648
9649 /**
9650  * Serialize the NodeAnnouncement object into a byte array which can be read by NodeAnnouncement_read
9651  */
9652 struct LDKCVec_u8Z NodeAnnouncement_write(const struct LDKNodeAnnouncement *NONNULL_PTR obj);
9653
9654 /**
9655  * Read a NodeAnnouncement from a byte array, created by NodeAnnouncement_write
9656  */
9657 struct LDKCResult_NodeAnnouncementDecodeErrorZ NodeAnnouncement_read(struct LDKu8slice ser);
9658
9659 /**
9660  * Read a QueryShortChannelIds from a byte array, created by QueryShortChannelIds_write
9661  */
9662 struct LDKCResult_QueryShortChannelIdsDecodeErrorZ QueryShortChannelIds_read(struct LDKu8slice ser);
9663
9664 /**
9665  * Serialize the QueryShortChannelIds object into a byte array which can be read by QueryShortChannelIds_read
9666  */
9667 struct LDKCVec_u8Z QueryShortChannelIds_write(const struct LDKQueryShortChannelIds *NONNULL_PTR obj);
9668
9669 /**
9670  * Read a ReplyShortChannelIdsEnd from a byte array, created by ReplyShortChannelIdsEnd_write
9671  */
9672 struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ ReplyShortChannelIdsEnd_read(struct LDKu8slice ser);
9673
9674 /**
9675  * Serialize the ReplyShortChannelIdsEnd object into a byte array which can be read by ReplyShortChannelIdsEnd_read
9676  */
9677 struct LDKCVec_u8Z ReplyShortChannelIdsEnd_write(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR obj);
9678
9679 /**
9680  *\n\t * Calculates the overflow safe ending block height for the query.\n\t * Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`\n\t
9681  */
9682 MUST_USE_RES uint32_t QueryChannelRange_end_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_arg);
9683
9684 /**
9685  * Read a QueryChannelRange from a byte array, created by QueryChannelRange_write
9686  */
9687 struct LDKCResult_QueryChannelRangeDecodeErrorZ QueryChannelRange_read(struct LDKu8slice ser);
9688
9689 /**
9690  * Serialize the QueryChannelRange object into a byte array which can be read by QueryChannelRange_read
9691  */
9692 struct LDKCVec_u8Z QueryChannelRange_write(const struct LDKQueryChannelRange *NONNULL_PTR obj);
9693
9694 /**
9695  * Read a ReplyChannelRange from a byte array, created by ReplyChannelRange_write
9696  */
9697 struct LDKCResult_ReplyChannelRangeDecodeErrorZ ReplyChannelRange_read(struct LDKu8slice ser);
9698
9699 /**
9700  * Serialize the ReplyChannelRange object into a byte array which can be read by ReplyChannelRange_read
9701  */
9702 struct LDKCVec_u8Z ReplyChannelRange_write(const struct LDKReplyChannelRange *NONNULL_PTR obj);
9703
9704 /**
9705  * Read a GossipTimestampFilter from a byte array, created by GossipTimestampFilter_write
9706  */
9707 struct LDKCResult_GossipTimestampFilterDecodeErrorZ GossipTimestampFilter_read(struct LDKu8slice ser);
9708
9709 /**
9710  * Serialize the GossipTimestampFilter object into a byte array which can be read by GossipTimestampFilter_read
9711  */
9712 struct LDKCVec_u8Z GossipTimestampFilter_write(const struct LDKGossipTimestampFilter *NONNULL_PTR obj);
9713
9714 /**
9715  * Frees any resources used by the IgnoringMessageHandler, if is_owned is set and inner is non-NULL.
9716  */
9717 void IgnoringMessageHandler_free(struct LDKIgnoringMessageHandler this_obj);
9718
9719 /**
9720  * Constructs a new IgnoringMessageHandler given each field
9721  */
9722 MUST_USE_RES struct LDKIgnoringMessageHandler IgnoringMessageHandler_new(void);
9723
9724 /**
9725  * Constructs a new MessageSendEventsProvider which calls the relevant methods on this_arg.
9726  * This copies the `inner` pointer in this_arg and thus the returned MessageSendEventsProvider must be freed before this_arg is
9727  */
9728 struct LDKMessageSendEventsProvider IgnoringMessageHandler_as_MessageSendEventsProvider(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
9729
9730 /**
9731  * Constructs a new RoutingMessageHandler which calls the relevant methods on this_arg.
9732  * This copies the `inner` pointer in this_arg and thus the returned RoutingMessageHandler must be freed before this_arg is
9733  */
9734 struct LDKRoutingMessageHandler IgnoringMessageHandler_as_RoutingMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
9735
9736 /**
9737  * Frees any resources used by the ErroringMessageHandler, if is_owned is set and inner is non-NULL.
9738  */
9739 void ErroringMessageHandler_free(struct LDKErroringMessageHandler this_obj);
9740
9741 /**
9742  * Constructs a new ErroringMessageHandler
9743  */
9744 MUST_USE_RES struct LDKErroringMessageHandler ErroringMessageHandler_new(void);
9745
9746 /**
9747  * Constructs a new MessageSendEventsProvider which calls the relevant methods on this_arg.
9748  * This copies the `inner` pointer in this_arg and thus the returned MessageSendEventsProvider must be freed before this_arg is
9749  */
9750 struct LDKMessageSendEventsProvider ErroringMessageHandler_as_MessageSendEventsProvider(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
9751
9752 /**
9753  * Constructs a new ChannelMessageHandler which calls the relevant methods on this_arg.
9754  * This copies the `inner` pointer in this_arg and thus the returned ChannelMessageHandler must be freed before this_arg is
9755  */
9756 struct LDKChannelMessageHandler ErroringMessageHandler_as_ChannelMessageHandler(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
9757
9758 /**
9759  * Frees any resources used by the MessageHandler, if is_owned is set and inner is non-NULL.
9760  */
9761 void MessageHandler_free(struct LDKMessageHandler this_obj);
9762
9763 /**
9764  * A message handler which handles messages specific to channels. Usually this is just a
9765  * ChannelManager object or a ErroringMessageHandler.
9766  */
9767 const struct LDKChannelMessageHandler *MessageHandler_get_chan_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
9768
9769 /**
9770  * A message handler which handles messages specific to channels. Usually this is just a
9771  * ChannelManager object or a ErroringMessageHandler.
9772  */
9773 void MessageHandler_set_chan_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKChannelMessageHandler val);
9774
9775 /**
9776  * A message handler which handles messages updating our knowledge of the network channel
9777  * graph. Usually this is just a NetGraphMsgHandlerMonitor object or an IgnoringMessageHandler.
9778  */
9779 const struct LDKRoutingMessageHandler *MessageHandler_get_route_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
9780
9781 /**
9782  * A message handler which handles messages updating our knowledge of the network channel
9783  * graph. Usually this is just a NetGraphMsgHandlerMonitor object or an IgnoringMessageHandler.
9784  */
9785 void MessageHandler_set_route_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKRoutingMessageHandler val);
9786
9787 /**
9788  * Constructs a new MessageHandler given each field
9789  */
9790 MUST_USE_RES struct LDKMessageHandler MessageHandler_new(struct LDKChannelMessageHandler chan_handler_arg, struct LDKRoutingMessageHandler route_handler_arg);
9791
9792 /**
9793  * Creates a copy of a SocketDescriptor
9794  */
9795 struct LDKSocketDescriptor SocketDescriptor_clone(const struct LDKSocketDescriptor *NONNULL_PTR orig);
9796
9797 /**
9798  * Calls the free function if one is set
9799  */
9800 void SocketDescriptor_free(struct LDKSocketDescriptor this_ptr);
9801
9802 /**
9803  * Frees any resources used by the PeerHandleError, if is_owned is set and inner is non-NULL.
9804  */
9805 void PeerHandleError_free(struct LDKPeerHandleError this_obj);
9806
9807 /**
9808  * Used to indicate that we probably can't make any future connections to this peer, implying
9809  * we should go ahead and force-close any channels we have with it.
9810  */
9811 bool PeerHandleError_get_no_connection_possible(const struct LDKPeerHandleError *NONNULL_PTR this_ptr);
9812
9813 /**
9814  * Used to indicate that we probably can't make any future connections to this peer, implying
9815  * we should go ahead and force-close any channels we have with it.
9816  */
9817 void PeerHandleError_set_no_connection_possible(struct LDKPeerHandleError *NONNULL_PTR this_ptr, bool val);
9818
9819 /**
9820  * Constructs a new PeerHandleError given each field
9821  */
9822 MUST_USE_RES struct LDKPeerHandleError PeerHandleError_new(bool no_connection_possible_arg);
9823
9824 /**
9825  * Creates a copy of the PeerHandleError
9826  */
9827 struct LDKPeerHandleError PeerHandleError_clone(const struct LDKPeerHandleError *NONNULL_PTR orig);
9828
9829 /**
9830  * Frees any resources used by the PeerManager, if is_owned is set and inner is non-NULL.
9831  */
9832 void PeerManager_free(struct LDKPeerManager this_obj);
9833
9834 /**
9835  * Constructs a new PeerManager with the given message handlers and node_id secret key
9836  * ephemeral_random_data is used to derive per-connection ephemeral keys and must be
9837  * cryptographically secure random bytes.
9838  */
9839 MUST_USE_RES struct LDKPeerManager PeerManager_new(struct LDKMessageHandler message_handler, struct LDKSecretKey our_node_secret, const uint8_t (*ephemeral_random_data)[32], struct LDKLogger logger);
9840
9841 /**
9842  * Get the list of node ids for peers which have completed the initial handshake.
9843  *
9844  * For outbound connections, this will be the same as the their_node_id parameter passed in to
9845  * new_outbound_connection, however entries will only appear once the initial handshake has
9846  * completed and we are sure the remote peer has the private key for the given node_id.
9847  */
9848 MUST_USE_RES struct LDKCVec_PublicKeyZ PeerManager_get_peer_node_ids(const struct LDKPeerManager *NONNULL_PTR this_arg);
9849
9850 /**
9851  * Indicates a new outbound connection has been established to a node with the given node_id.
9852  * Note that if an Err is returned here you MUST NOT call socket_disconnected for the new
9853  * descriptor but must disconnect the connection immediately.
9854  *
9855  * Returns a small number of bytes to send to the remote node (currently always 50).
9856  *
9857  * Panics if descriptor is duplicative with some other descriptor which has not yet had a
9858  * socket_disconnected().
9859  */
9860 MUST_USE_RES struct LDKCResult_CVec_u8ZPeerHandleErrorZ PeerManager_new_outbound_connection(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKSocketDescriptor descriptor);
9861
9862 /**
9863  * Indicates a new inbound connection has been established.
9864  *
9865  * May refuse the connection by returning an Err, but will never write bytes to the remote end
9866  * (outbound connector always speaks first). Note that if an Err is returned here you MUST NOT
9867  * call socket_disconnected for the new descriptor but must disconnect the connection
9868  * immediately.
9869  *
9870  * Panics if descriptor is duplicative with some other descriptor which has not yet had
9871  * socket_disconnected called.
9872  */
9873 MUST_USE_RES struct LDKCResult_NonePeerHandleErrorZ PeerManager_new_inbound_connection(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKSocketDescriptor descriptor);
9874
9875 /**
9876  * Indicates that there is room to write data to the given socket descriptor.
9877  *
9878  * May return an Err to indicate that the connection should be closed.
9879  *
9880  * Will most likely call send_data on the descriptor passed in (or the descriptor handed into
9881  * new_*\\_connection) before returning. Thus, be very careful with reentrancy issues! The
9882  * invariants around calling write_buffer_space_avail in case a write did not fully complete
9883  * must still hold - be ready to call write_buffer_space_avail again if a write call generated
9884  * here isn't sufficient! Panics if the descriptor was not previously registered in a
9885  * new_\\*_connection event.
9886  */
9887 MUST_USE_RES struct LDKCResult_NonePeerHandleErrorZ PeerManager_write_buffer_space_avail(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKSocketDescriptor *NONNULL_PTR descriptor);
9888
9889 /**
9890  * Indicates that data was read from the given socket descriptor.
9891  *
9892  * May return an Err to indicate that the connection should be closed.
9893  *
9894  * Will *not* call back into send_data on any descriptors to avoid reentrancy complexity.
9895  * Thus, however, you almost certainly want to call process_events() after any read_event to
9896  * generate send_data calls to handle responses.
9897  *
9898  * If Ok(true) is returned, further read_events should not be triggered until a send_data call
9899  * on this file descriptor has resume_read set (preventing DoS issues in the send buffer).
9900  *
9901  * Panics if the descriptor was not previously registered in a new_*_connection event.
9902  */
9903 MUST_USE_RES struct LDKCResult_boolPeerHandleErrorZ PeerManager_read_event(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKSocketDescriptor *NONNULL_PTR peer_descriptor, struct LDKu8slice data);
9904
9905 /**
9906  * Checks for any events generated by our handlers and processes them. Includes sending most
9907  * response messages as well as messages generated by calls to handler functions directly (eg
9908  * functions like ChannelManager::process_pending_htlc_forward or send_payment).
9909  */
9910 void PeerManager_process_events(const struct LDKPeerManager *NONNULL_PTR this_arg);
9911
9912 /**
9913  * Indicates that the given socket descriptor's connection is now closed.
9914  *
9915  * This must only be called if the socket has been disconnected by the peer or your own
9916  * decision to disconnect it and must NOT be called in any case where other parts of this
9917  * library (eg PeerHandleError, explicit disconnect_socket calls) instruct you to disconnect
9918  * the peer.
9919  *
9920  * Panics if the descriptor was not previously registered in a successful new_*_connection event.
9921  */
9922 void PeerManager_socket_disconnected(const struct LDKPeerManager *NONNULL_PTR this_arg, const struct LDKSocketDescriptor *NONNULL_PTR descriptor);
9923
9924 /**
9925  * Disconnect a peer given its node id.
9926  *
9927  * Set no_connection_possible to true to prevent any further connection with this peer,
9928  * force-closing any channels we have with it.
9929  *
9930  * If a peer is connected, this will call `disconnect_socket` on the descriptor for the peer,
9931  * so be careful about reentrancy issues.
9932  */
9933 void PeerManager_disconnect_by_node_id(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKPublicKey node_id, bool no_connection_possible);
9934
9935 /**
9936  * This function should be called roughly once every 30 seconds.
9937  * It will send pings to each peer and disconnect those which did not respond to the last round of pings.
9938  * Will most likely call send_data on all of the registered descriptors, thus, be very careful with reentrancy issues!
9939  */
9940 void PeerManager_timer_tick_occurred(const struct LDKPeerManager *NONNULL_PTR this_arg);
9941
9942 /**
9943  * Build the commitment secret from the seed and the commitment number
9944  */
9945 struct LDKThirtyTwoBytes build_commitment_secret(const uint8_t (*commitment_seed)[32], uint64_t idx);
9946
9947 /**
9948  * Derives a per-commitment-transaction private key (eg an htlc key or delayed_payment key)
9949  * from the base secret and the per_commitment_point.
9950  *
9951  * Note that this is infallible iff we trust that at least one of the two input keys are randomly
9952  * generated (ie our own).
9953  */
9954 struct LDKCResult_SecretKeyErrorZ derive_private_key(struct LDKPublicKey per_commitment_point, const uint8_t (*base_secret)[32]);
9955
9956 /**
9957  * Derives a per-commitment-transaction public key (eg an htlc key or a delayed_payment key)
9958  * from the base point and the per_commitment_key. This is the public equivalent of
9959  * derive_private_key - using only public keys to derive a public key instead of private keys.
9960  *
9961  * Note that this is infallible iff we trust that at least one of the two input keys are randomly
9962  * generated (ie our own).
9963  */
9964 struct LDKCResult_PublicKeyErrorZ derive_public_key(struct LDKPublicKey per_commitment_point, struct LDKPublicKey base_point);
9965
9966 /**
9967  * Derives a per-commitment-transaction revocation key from its constituent parts.
9968  *
9969  * Only the cheating participant owns a valid witness to propagate a revoked
9970  * commitment transaction, thus per_commitment_secret always come from cheater
9971  * and revocation_base_secret always come from punisher, which is the broadcaster
9972  * of the transaction spending with this key knowledge.
9973  *
9974  * Note that this is infallible iff we trust that at least one of the two input keys are randomly
9975  * generated (ie our own).
9976  */
9977 struct LDKCResult_SecretKeyErrorZ derive_private_revocation_key(const uint8_t (*per_commitment_secret)[32], const uint8_t (*countersignatory_revocation_base_secret)[32]);
9978
9979 /**
9980  * Derives a per-commitment-transaction revocation public key from its constituent parts. This is
9981  * the public equivalend of derive_private_revocation_key - using only public keys to derive a
9982  * public key instead of private keys.
9983  *
9984  * Only the cheating participant owns a valid witness to propagate a revoked
9985  * commitment transaction, thus per_commitment_point always come from cheater
9986  * and revocation_base_point always come from punisher, which is the broadcaster
9987  * of the transaction spending with this key knowledge.
9988  *
9989  * Note that this is infallible iff we trust that at least one of the two input keys are randomly
9990  * generated (ie our own).
9991  */
9992 struct LDKCResult_PublicKeyErrorZ derive_public_revocation_key(struct LDKPublicKey per_commitment_point, struct LDKPublicKey countersignatory_revocation_base_point);
9993
9994 /**
9995  * Frees any resources used by the TxCreationKeys, if is_owned is set and inner is non-NULL.
9996  */
9997 void TxCreationKeys_free(struct LDKTxCreationKeys this_obj);
9998
9999 /**
10000  * The broadcaster's per-commitment public key which was used to derive the other keys.
10001  */
10002 struct LDKPublicKey TxCreationKeys_get_per_commitment_point(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
10003
10004 /**
10005  * The broadcaster's per-commitment public key which was used to derive the other keys.
10006  */
10007 void TxCreationKeys_set_per_commitment_point(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
10008
10009 /**
10010  * The revocation key which is used to allow the broadcaster of the commitment
10011  * transaction to provide their counterparty the ability to punish them if they broadcast
10012  * an old state.
10013  */
10014 struct LDKPublicKey TxCreationKeys_get_revocation_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
10015
10016 /**
10017  * The revocation key which is used to allow the broadcaster of the commitment
10018  * transaction to provide their counterparty the ability to punish them if they broadcast
10019  * an old state.
10020  */
10021 void TxCreationKeys_set_revocation_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
10022
10023 /**
10024  * Broadcaster's HTLC Key
10025  */
10026 struct LDKPublicKey TxCreationKeys_get_broadcaster_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
10027
10028 /**
10029  * Broadcaster's HTLC Key
10030  */
10031 void TxCreationKeys_set_broadcaster_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
10032
10033 /**
10034  * Countersignatory's HTLC Key
10035  */
10036 struct LDKPublicKey TxCreationKeys_get_countersignatory_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
10037
10038 /**
10039  * Countersignatory's HTLC Key
10040  */
10041 void TxCreationKeys_set_countersignatory_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
10042
10043 /**
10044  * Broadcaster's Payment Key (which isn't allowed to be spent from for some delay)
10045  */
10046 struct LDKPublicKey TxCreationKeys_get_broadcaster_delayed_payment_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
10047
10048 /**
10049  * Broadcaster's Payment Key (which isn't allowed to be spent from for some delay)
10050  */
10051 void TxCreationKeys_set_broadcaster_delayed_payment_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
10052
10053 /**
10054  * Constructs a new TxCreationKeys given each field
10055  */
10056 MUST_USE_RES struct LDKTxCreationKeys TxCreationKeys_new(struct LDKPublicKey per_commitment_point_arg, struct LDKPublicKey revocation_key_arg, struct LDKPublicKey broadcaster_htlc_key_arg, struct LDKPublicKey countersignatory_htlc_key_arg, struct LDKPublicKey broadcaster_delayed_payment_key_arg);
10057
10058 /**
10059  * Creates a copy of the TxCreationKeys
10060  */
10061 struct LDKTxCreationKeys TxCreationKeys_clone(const struct LDKTxCreationKeys *NONNULL_PTR orig);
10062
10063 /**
10064  * Serialize the TxCreationKeys object into a byte array which can be read by TxCreationKeys_read
10065  */
10066 struct LDKCVec_u8Z TxCreationKeys_write(const struct LDKTxCreationKeys *NONNULL_PTR obj);
10067
10068 /**
10069  * Read a TxCreationKeys from a byte array, created by TxCreationKeys_write
10070  */
10071 struct LDKCResult_TxCreationKeysDecodeErrorZ TxCreationKeys_read(struct LDKu8slice ser);
10072
10073 /**
10074  * Frees any resources used by the ChannelPublicKeys, if is_owned is set and inner is non-NULL.
10075  */
10076 void ChannelPublicKeys_free(struct LDKChannelPublicKeys this_obj);
10077
10078 /**
10079  * The public key which is used to sign all commitment transactions, as it appears in the
10080  * on-chain channel lock-in 2-of-2 multisig output.
10081  */
10082 struct LDKPublicKey ChannelPublicKeys_get_funding_pubkey(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
10083
10084 /**
10085  * The public key which is used to sign all commitment transactions, as it appears in the
10086  * on-chain channel lock-in 2-of-2 multisig output.
10087  */
10088 void ChannelPublicKeys_set_funding_pubkey(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
10089
10090 /**
10091  * The base point which is used (with derive_public_revocation_key) to derive per-commitment
10092  * revocation keys. This is combined with the per-commitment-secret generated by the
10093  * counterparty to create a secret which the counterparty can reveal to revoke previous
10094  * states.
10095  */
10096 struct LDKPublicKey ChannelPublicKeys_get_revocation_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
10097
10098 /**
10099  * The base point which is used (with derive_public_revocation_key) to derive per-commitment
10100  * revocation keys. This is combined with the per-commitment-secret generated by the
10101  * counterparty to create a secret which the counterparty can reveal to revoke previous
10102  * states.
10103  */
10104 void ChannelPublicKeys_set_revocation_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
10105
10106 /**
10107  * The public key on which the non-broadcaster (ie the countersignatory) receives an immediately
10108  * spendable primary channel balance on the broadcaster's commitment transaction. This key is
10109  * static across every commitment transaction.
10110  */
10111 struct LDKPublicKey ChannelPublicKeys_get_payment_point(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
10112
10113 /**
10114  * The public key on which the non-broadcaster (ie the countersignatory) receives an immediately
10115  * spendable primary channel balance on the broadcaster's commitment transaction. This key is
10116  * static across every commitment transaction.
10117  */
10118 void ChannelPublicKeys_set_payment_point(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
10119
10120 /**
10121  * The base point which is used (with derive_public_key) to derive a per-commitment payment
10122  * public key which receives non-HTLC-encumbered funds which are only available for spending
10123  * after some delay (or can be claimed via the revocation path).
10124  */
10125 struct LDKPublicKey ChannelPublicKeys_get_delayed_payment_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
10126
10127 /**
10128  * The base point which is used (with derive_public_key) to derive a per-commitment payment
10129  * public key which receives non-HTLC-encumbered funds which are only available for spending
10130  * after some delay (or can be claimed via the revocation path).
10131  */
10132 void ChannelPublicKeys_set_delayed_payment_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
10133
10134 /**
10135  * The base point which is used (with derive_public_key) to derive a per-commitment public key
10136  * which is used to encumber HTLC-in-flight outputs.
10137  */
10138 struct LDKPublicKey ChannelPublicKeys_get_htlc_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
10139
10140 /**
10141  * The base point which is used (with derive_public_key) to derive a per-commitment public key
10142  * which is used to encumber HTLC-in-flight outputs.
10143  */
10144 void ChannelPublicKeys_set_htlc_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
10145
10146 /**
10147  * Constructs a new ChannelPublicKeys given each field
10148  */
10149 MUST_USE_RES struct LDKChannelPublicKeys ChannelPublicKeys_new(struct LDKPublicKey funding_pubkey_arg, struct LDKPublicKey revocation_basepoint_arg, struct LDKPublicKey payment_point_arg, struct LDKPublicKey delayed_payment_basepoint_arg, struct LDKPublicKey htlc_basepoint_arg);
10150
10151 /**
10152  * Creates a copy of the ChannelPublicKeys
10153  */
10154 struct LDKChannelPublicKeys ChannelPublicKeys_clone(const struct LDKChannelPublicKeys *NONNULL_PTR orig);
10155
10156 /**
10157  * Serialize the ChannelPublicKeys object into a byte array which can be read by ChannelPublicKeys_read
10158  */
10159 struct LDKCVec_u8Z ChannelPublicKeys_write(const struct LDKChannelPublicKeys *NONNULL_PTR obj);
10160
10161 /**
10162  * Read a ChannelPublicKeys from a byte array, created by ChannelPublicKeys_write
10163  */
10164 struct LDKCResult_ChannelPublicKeysDecodeErrorZ ChannelPublicKeys_read(struct LDKu8slice ser);
10165
10166 /**
10167  * Create per-state keys from channel base points and the per-commitment point.
10168  * Key set is asymmetric and can't be used as part of counter-signatory set of transactions.
10169  */
10170 MUST_USE_RES struct LDKCResult_TxCreationKeysErrorZ TxCreationKeys_derive_new(struct LDKPublicKey per_commitment_point, struct LDKPublicKey broadcaster_delayed_payment_base, struct LDKPublicKey broadcaster_htlc_base, struct LDKPublicKey countersignatory_revocation_base, struct LDKPublicKey countersignatory_htlc_base);
10171
10172 /**
10173  * Generate per-state keys from channel static keys.
10174  * Key set is asymmetric and can't be used as part of counter-signatory set of transactions.
10175  */
10176 MUST_USE_RES struct LDKCResult_TxCreationKeysErrorZ TxCreationKeys_from_channel_static_keys(struct LDKPublicKey per_commitment_point, const struct LDKChannelPublicKeys *NONNULL_PTR broadcaster_keys, const struct LDKChannelPublicKeys *NONNULL_PTR countersignatory_keys);
10177
10178 /**
10179  * A script either spendable by the revocation
10180  * key or the broadcaster_delayed_payment_key and satisfying the relative-locktime OP_CSV constrain.
10181  * Encumbering a `to_holder` output on a commitment transaction or 2nd-stage HTLC transactions.
10182  */
10183 struct LDKCVec_u8Z get_revokeable_redeemscript(struct LDKPublicKey revocation_key, uint16_t contest_delay, struct LDKPublicKey broadcaster_delayed_payment_key);
10184
10185 /**
10186  * Frees any resources used by the HTLCOutputInCommitment, if is_owned is set and inner is non-NULL.
10187  */
10188 void HTLCOutputInCommitment_free(struct LDKHTLCOutputInCommitment this_obj);
10189
10190 /**
10191  * Whether the HTLC was \"offered\" (ie outbound in relation to this commitment transaction).
10192  * Note that this is not the same as whether it is ountbound *from us*. To determine that you
10193  * need to compare this value to whether the commitment transaction in question is that of
10194  * the counterparty or our own.
10195  */
10196 bool HTLCOutputInCommitment_get_offered(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
10197
10198 /**
10199  * Whether the HTLC was \"offered\" (ie outbound in relation to this commitment transaction).
10200  * Note that this is not the same as whether it is ountbound *from us*. To determine that you
10201  * need to compare this value to whether the commitment transaction in question is that of
10202  * the counterparty or our own.
10203  */
10204 void HTLCOutputInCommitment_set_offered(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, bool val);
10205
10206 /**
10207  * The value, in msat, of the HTLC. The value as it appears in the commitment transaction is
10208  * this divided by 1000.
10209  */
10210 uint64_t HTLCOutputInCommitment_get_amount_msat(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
10211
10212 /**
10213  * The value, in msat, of the HTLC. The value as it appears in the commitment transaction is
10214  * this divided by 1000.
10215  */
10216 void HTLCOutputInCommitment_set_amount_msat(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint64_t val);
10217
10218 /**
10219  * The CLTV lock-time at which this HTLC expires.
10220  */
10221 uint32_t HTLCOutputInCommitment_get_cltv_expiry(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
10222
10223 /**
10224  * The CLTV lock-time at which this HTLC expires.
10225  */
10226 void HTLCOutputInCommitment_set_cltv_expiry(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint32_t val);
10227
10228 /**
10229  * The hash of the preimage which unlocks this HTLC.
10230  */
10231 const uint8_t (*HTLCOutputInCommitment_get_payment_hash(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr))[32];
10232
10233 /**
10234  * The hash of the preimage which unlocks this HTLC.
10235  */
10236 void HTLCOutputInCommitment_set_payment_hash(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
10237
10238 /**
10239  * Creates a copy of the HTLCOutputInCommitment
10240  */
10241 struct LDKHTLCOutputInCommitment HTLCOutputInCommitment_clone(const struct LDKHTLCOutputInCommitment *NONNULL_PTR orig);
10242
10243 /**
10244  * Serialize the HTLCOutputInCommitment object into a byte array which can be read by HTLCOutputInCommitment_read
10245  */
10246 struct LDKCVec_u8Z HTLCOutputInCommitment_write(const struct LDKHTLCOutputInCommitment *NONNULL_PTR obj);
10247
10248 /**
10249  * Read a HTLCOutputInCommitment from a byte array, created by HTLCOutputInCommitment_write
10250  */
10251 struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ HTLCOutputInCommitment_read(struct LDKu8slice ser);
10252
10253 /**
10254  * Gets the witness redeemscript for an HTLC output in a commitment transaction. Note that htlc
10255  * does not need to have its previous_output_index filled.
10256  */
10257 struct LDKCVec_u8Z get_htlc_redeemscript(const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc, const struct LDKTxCreationKeys *NONNULL_PTR keys);
10258
10259 /**
10260  * Gets the redeemscript for a funding output from the two funding public keys.
10261  * Note that the order of funding public keys does not matter.
10262  */
10263 struct LDKCVec_u8Z make_funding_redeemscript(struct LDKPublicKey broadcaster, struct LDKPublicKey countersignatory);
10264
10265 /**
10266  * panics if htlc.transaction_output_index.is_none()!
10267  */
10268 struct LDKTransaction build_htlc_transaction(const uint8_t (*prev_hash)[32], uint32_t feerate_per_kw, uint16_t contest_delay, const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc, struct LDKPublicKey broadcaster_delayed_payment_key, struct LDKPublicKey revocation_key);
10269
10270 /**
10271  * Frees any resources used by the ChannelTransactionParameters, if is_owned is set and inner is non-NULL.
10272  */
10273 void ChannelTransactionParameters_free(struct LDKChannelTransactionParameters this_obj);
10274
10275 /**
10276  * Holder public keys
10277  */
10278 struct LDKChannelPublicKeys ChannelTransactionParameters_get_holder_pubkeys(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
10279
10280 /**
10281  * Holder public keys
10282  */
10283 void ChannelTransactionParameters_set_holder_pubkeys(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
10284
10285 /**
10286  * The contest delay selected by the holder, which applies to counterparty-broadcast transactions
10287  */
10288 uint16_t ChannelTransactionParameters_get_holder_selected_contest_delay(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
10289
10290 /**
10291  * The contest delay selected by the holder, which applies to counterparty-broadcast transactions
10292  */
10293 void ChannelTransactionParameters_set_holder_selected_contest_delay(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
10294
10295 /**
10296  * Whether the holder is the initiator of this channel.
10297  * This is an input to the commitment number obscure factor computation.
10298  */
10299 bool ChannelTransactionParameters_get_is_outbound_from_holder(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
10300
10301 /**
10302  * Whether the holder is the initiator of this channel.
10303  * This is an input to the commitment number obscure factor computation.
10304  */
10305 void ChannelTransactionParameters_set_is_outbound_from_holder(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, bool val);
10306
10307 /**
10308  * The late-bound counterparty channel transaction parameters.
10309  * These parameters are populated at the point in the protocol where the counterparty provides them.
10310  */
10311 struct LDKCounterpartyChannelTransactionParameters ChannelTransactionParameters_get_counterparty_parameters(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
10312
10313 /**
10314  * The late-bound counterparty channel transaction parameters.
10315  * These parameters are populated at the point in the protocol where the counterparty provides them.
10316  */
10317 void ChannelTransactionParameters_set_counterparty_parameters(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKCounterpartyChannelTransactionParameters val);
10318
10319 /**
10320  * The late-bound funding outpoint
10321  */
10322 struct LDKOutPoint ChannelTransactionParameters_get_funding_outpoint(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
10323
10324 /**
10325  * The late-bound funding outpoint
10326  */
10327 void ChannelTransactionParameters_set_funding_outpoint(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKOutPoint val);
10328
10329 /**
10330  * Constructs a new ChannelTransactionParameters given each field
10331  */
10332 MUST_USE_RES struct LDKChannelTransactionParameters ChannelTransactionParameters_new(struct LDKChannelPublicKeys holder_pubkeys_arg, uint16_t holder_selected_contest_delay_arg, bool is_outbound_from_holder_arg, struct LDKCounterpartyChannelTransactionParameters counterparty_parameters_arg, struct LDKOutPoint funding_outpoint_arg);
10333
10334 /**
10335  * Creates a copy of the ChannelTransactionParameters
10336  */
10337 struct LDKChannelTransactionParameters ChannelTransactionParameters_clone(const struct LDKChannelTransactionParameters *NONNULL_PTR orig);
10338
10339 /**
10340  * Frees any resources used by the CounterpartyChannelTransactionParameters, if is_owned is set and inner is non-NULL.
10341  */
10342 void CounterpartyChannelTransactionParameters_free(struct LDKCounterpartyChannelTransactionParameters this_obj);
10343
10344 /**
10345  * Counter-party public keys
10346  */
10347 struct LDKChannelPublicKeys CounterpartyChannelTransactionParameters_get_pubkeys(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
10348
10349 /**
10350  * Counter-party public keys
10351  */
10352 void CounterpartyChannelTransactionParameters_set_pubkeys(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
10353
10354 /**
10355  * The contest delay selected by the counterparty, which applies to holder-broadcast transactions
10356  */
10357 uint16_t CounterpartyChannelTransactionParameters_get_selected_contest_delay(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
10358
10359 /**
10360  * The contest delay selected by the counterparty, which applies to holder-broadcast transactions
10361  */
10362 void CounterpartyChannelTransactionParameters_set_selected_contest_delay(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
10363
10364 /**
10365  * Constructs a new CounterpartyChannelTransactionParameters given each field
10366  */
10367 MUST_USE_RES struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_new(struct LDKChannelPublicKeys pubkeys_arg, uint16_t selected_contest_delay_arg);
10368
10369 /**
10370  * Creates a copy of the CounterpartyChannelTransactionParameters
10371  */
10372 struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_clone(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR orig);
10373
10374 /**
10375  * Whether the late bound parameters are populated.
10376  */
10377 MUST_USE_RES bool ChannelTransactionParameters_is_populated(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
10378
10379 /**
10380  * Convert the holder/counterparty parameters to broadcaster/countersignatory-organized parameters,
10381  * given that the holder is the broadcaster.
10382  *
10383  * self.is_populated() must be true before calling this function.
10384  */
10385 MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_holder_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
10386
10387 /**
10388  * Convert the holder/counterparty parameters to broadcaster/countersignatory-organized parameters,
10389  * given that the counterparty is the broadcaster.
10390  *
10391  * self.is_populated() must be true before calling this function.
10392  */
10393 MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_counterparty_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
10394
10395 /**
10396  * Serialize the CounterpartyChannelTransactionParameters object into a byte array which can be read by CounterpartyChannelTransactionParameters_read
10397  */
10398 struct LDKCVec_u8Z CounterpartyChannelTransactionParameters_write(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR obj);
10399
10400 /**
10401  * Read a CounterpartyChannelTransactionParameters from a byte array, created by CounterpartyChannelTransactionParameters_write
10402  */
10403 struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CounterpartyChannelTransactionParameters_read(struct LDKu8slice ser);
10404
10405 /**
10406  * Serialize the ChannelTransactionParameters object into a byte array which can be read by ChannelTransactionParameters_read
10407  */
10408 struct LDKCVec_u8Z ChannelTransactionParameters_write(const struct LDKChannelTransactionParameters *NONNULL_PTR obj);
10409
10410 /**
10411  * Read a ChannelTransactionParameters from a byte array, created by ChannelTransactionParameters_write
10412  */
10413 struct LDKCResult_ChannelTransactionParametersDecodeErrorZ ChannelTransactionParameters_read(struct LDKu8slice ser);
10414
10415 /**
10416  * Frees any resources used by the DirectedChannelTransactionParameters, if is_owned is set and inner is non-NULL.
10417  */
10418 void DirectedChannelTransactionParameters_free(struct LDKDirectedChannelTransactionParameters this_obj);
10419
10420 /**
10421  * Get the channel pubkeys for the broadcaster
10422  */
10423 MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_broadcaster_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
10424
10425 /**
10426  * Get the channel pubkeys for the countersignatory
10427  */
10428 MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_countersignatory_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
10429
10430 /**
10431  * Get the contest delay applicable to the transactions.
10432  * Note that the contest delay was selected by the countersignatory.
10433  */
10434 MUST_USE_RES uint16_t DirectedChannelTransactionParameters_contest_delay(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
10435
10436 /**
10437  * Whether the channel is outbound from the broadcaster.
10438  *
10439  * The boolean representing the side that initiated the channel is
10440  * an input to the commitment number obscure factor computation.
10441  */
10442 MUST_USE_RES bool DirectedChannelTransactionParameters_is_outbound(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
10443
10444 /**
10445  * The funding outpoint
10446  */
10447 MUST_USE_RES struct LDKOutPoint DirectedChannelTransactionParameters_funding_outpoint(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
10448
10449 /**
10450  * Frees any resources used by the HolderCommitmentTransaction, if is_owned is set and inner is non-NULL.
10451  */
10452 void HolderCommitmentTransaction_free(struct LDKHolderCommitmentTransaction this_obj);
10453
10454 /**
10455  * Our counterparty's signature for the transaction
10456  */
10457 struct LDKSignature HolderCommitmentTransaction_get_counterparty_sig(const struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr);
10458
10459 /**
10460  * Our counterparty's signature for the transaction
10461  */
10462 void HolderCommitmentTransaction_set_counterparty_sig(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKSignature val);
10463
10464 /**
10465  * All non-dust counterparty HTLC signatures, in the order they appear in the transaction
10466  */
10467 void HolderCommitmentTransaction_set_counterparty_htlc_sigs(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKCVec_SignatureZ val);
10468
10469 /**
10470  * Creates a copy of the HolderCommitmentTransaction
10471  */
10472 struct LDKHolderCommitmentTransaction HolderCommitmentTransaction_clone(const struct LDKHolderCommitmentTransaction *NONNULL_PTR orig);
10473
10474 /**
10475  * Serialize the HolderCommitmentTransaction object into a byte array which can be read by HolderCommitmentTransaction_read
10476  */
10477 struct LDKCVec_u8Z HolderCommitmentTransaction_write(const struct LDKHolderCommitmentTransaction *NONNULL_PTR obj);
10478
10479 /**
10480  * Read a HolderCommitmentTransaction from a byte array, created by HolderCommitmentTransaction_write
10481  */
10482 struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ HolderCommitmentTransaction_read(struct LDKu8slice ser);
10483
10484 /**
10485  * Create a new holder transaction with the given counterparty signatures.
10486  * The funding keys are used to figure out which signature should go first when building the transaction for broadcast.
10487  */
10488 MUST_USE_RES struct LDKHolderCommitmentTransaction HolderCommitmentTransaction_new(struct LDKCommitmentTransaction commitment_tx, struct LDKSignature counterparty_sig, struct LDKCVec_SignatureZ counterparty_htlc_sigs, struct LDKPublicKey holder_funding_key, struct LDKPublicKey counterparty_funding_key);
10489
10490 /**
10491  * Frees any resources used by the BuiltCommitmentTransaction, if is_owned is set and inner is non-NULL.
10492  */
10493 void BuiltCommitmentTransaction_free(struct LDKBuiltCommitmentTransaction this_obj);
10494
10495 /**
10496  * The commitment transaction
10497  */
10498 struct LDKTransaction BuiltCommitmentTransaction_get_transaction(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr);
10499
10500 /**
10501  * The commitment transaction
10502  */
10503 void BuiltCommitmentTransaction_set_transaction(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKTransaction val);
10504
10505 /**
10506  * The txid for the commitment transaction.
10507  *
10508  * This is provided as a performance optimization, instead of calling transaction.txid()
10509  * multiple times.
10510  */
10511 const uint8_t (*BuiltCommitmentTransaction_get_txid(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr))[32];
10512
10513 /**
10514  * The txid for the commitment transaction.
10515  *
10516  * This is provided as a performance optimization, instead of calling transaction.txid()
10517  * multiple times.
10518  */
10519 void BuiltCommitmentTransaction_set_txid(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
10520
10521 /**
10522  * Constructs a new BuiltCommitmentTransaction given each field
10523  */
10524 MUST_USE_RES struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_new(struct LDKTransaction transaction_arg, struct LDKThirtyTwoBytes txid_arg);
10525
10526 /**
10527  * Creates a copy of the BuiltCommitmentTransaction
10528  */
10529 struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_clone(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR orig);
10530
10531 /**
10532  * Serialize the BuiltCommitmentTransaction object into a byte array which can be read by BuiltCommitmentTransaction_read
10533  */
10534 struct LDKCVec_u8Z BuiltCommitmentTransaction_write(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR obj);
10535
10536 /**
10537  * Read a BuiltCommitmentTransaction from a byte array, created by BuiltCommitmentTransaction_write
10538  */
10539 struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ BuiltCommitmentTransaction_read(struct LDKu8slice ser);
10540
10541 /**
10542  * Get the SIGHASH_ALL sighash value of the transaction.
10543  *
10544  * This can be used to verify a signature.
10545  */
10546 MUST_USE_RES struct LDKThirtyTwoBytes BuiltCommitmentTransaction_get_sighash_all(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_arg, struct LDKu8slice funding_redeemscript, uint64_t channel_value_satoshis);
10547
10548 /**
10549  * Sign a transaction, either because we are counter-signing the counterparty's transaction or
10550  * because we are about to broadcast a holder transaction.
10551  */
10552 MUST_USE_RES struct LDKSignature BuiltCommitmentTransaction_sign(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_arg, const uint8_t (*funding_key)[32], struct LDKu8slice funding_redeemscript, uint64_t channel_value_satoshis);
10553
10554 /**
10555  * Frees any resources used by the CommitmentTransaction, if is_owned is set and inner is non-NULL.
10556  */
10557 void CommitmentTransaction_free(struct LDKCommitmentTransaction this_obj);
10558
10559 /**
10560  * Creates a copy of the CommitmentTransaction
10561  */
10562 struct LDKCommitmentTransaction CommitmentTransaction_clone(const struct LDKCommitmentTransaction *NONNULL_PTR orig);
10563
10564 /**
10565  * Serialize the CommitmentTransaction object into a byte array which can be read by CommitmentTransaction_read
10566  */
10567 struct LDKCVec_u8Z CommitmentTransaction_write(const struct LDKCommitmentTransaction *NONNULL_PTR obj);
10568
10569 /**
10570  * Read a CommitmentTransaction from a byte array, created by CommitmentTransaction_write
10571  */
10572 struct LDKCResult_CommitmentTransactionDecodeErrorZ CommitmentTransaction_read(struct LDKu8slice ser);
10573
10574 /**
10575  * The backwards-counting commitment number
10576  */
10577 MUST_USE_RES uint64_t CommitmentTransaction_commitment_number(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
10578
10579 /**
10580  * The value to be sent to the broadcaster
10581  */
10582 MUST_USE_RES uint64_t CommitmentTransaction_to_broadcaster_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
10583
10584 /**
10585  * The value to be sent to the counterparty
10586  */
10587 MUST_USE_RES uint64_t CommitmentTransaction_to_countersignatory_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
10588
10589 /**
10590  * The feerate paid per 1000-weight-unit in this commitment transaction.
10591  */
10592 MUST_USE_RES uint32_t CommitmentTransaction_feerate_per_kw(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
10593
10594 /**
10595  * Trust our pre-built transaction and derived transaction creation public keys.
10596  *
10597  * Applies a wrapper which allows access to these fields.
10598  *
10599  * This should only be used if you fully trust the builder of this object.  It should not
10600  *\tbe used by an external signer - instead use the verify function.
10601  */
10602 MUST_USE_RES struct LDKTrustedCommitmentTransaction CommitmentTransaction_trust(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
10603
10604 /**
10605  * Verify our pre-built transaction and derived transaction creation public keys.
10606  *
10607  * Applies a wrapper which allows access to these fields.
10608  *
10609  * An external validating signer must call this method before signing
10610  * or using the built transaction.
10611  */
10612 MUST_USE_RES struct LDKCResult_TrustedCommitmentTransactionNoneZ CommitmentTransaction_verify(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg, const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR channel_parameters, const struct LDKChannelPublicKeys *NONNULL_PTR broadcaster_keys, const struct LDKChannelPublicKeys *NONNULL_PTR countersignatory_keys);
10613
10614 /**
10615  * Frees any resources used by the TrustedCommitmentTransaction, if is_owned is set and inner is non-NULL.
10616  */
10617 void TrustedCommitmentTransaction_free(struct LDKTrustedCommitmentTransaction this_obj);
10618
10619 /**
10620  * The transaction ID of the built Bitcoin transaction
10621  */
10622 MUST_USE_RES struct LDKThirtyTwoBytes TrustedCommitmentTransaction_txid(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
10623
10624 /**
10625  * The pre-built Bitcoin commitment transaction
10626  */
10627 MUST_USE_RES struct LDKBuiltCommitmentTransaction TrustedCommitmentTransaction_built_transaction(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
10628
10629 /**
10630  * The pre-calculated transaction creation public keys.
10631  */
10632 MUST_USE_RES struct LDKTxCreationKeys TrustedCommitmentTransaction_keys(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
10633
10634 /**
10635  * Get a signature for each HTLC which was included in the commitment transaction (ie for
10636  * which HTLCOutputInCommitment::transaction_output_index.is_some()).
10637  *
10638  * The returned Vec has one entry for each HTLC, and in the same order.
10639  */
10640 MUST_USE_RES struct LDKCResult_CVec_SignatureZNoneZ TrustedCommitmentTransaction_get_htlc_sigs(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg, const uint8_t (*htlc_base_key)[32], const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR channel_parameters);
10641
10642 /**
10643  * Get the transaction number obscure factor
10644  */
10645 uint64_t get_commitment_transaction_number_obscure_factor(struct LDKPublicKey broadcaster_payment_basepoint, struct LDKPublicKey countersignatory_payment_basepoint, bool outbound_from_broadcaster);
10646
10647 /**
10648  * Creates a copy of the InitFeatures
10649  */
10650 struct LDKInitFeatures InitFeatures_clone(const struct LDKInitFeatures *NONNULL_PTR orig);
10651
10652 /**
10653  * Creates a copy of the NodeFeatures
10654  */
10655 struct LDKNodeFeatures NodeFeatures_clone(const struct LDKNodeFeatures *NONNULL_PTR orig);
10656
10657 /**
10658  * Creates a copy of the ChannelFeatures
10659  */
10660 struct LDKChannelFeatures ChannelFeatures_clone(const struct LDKChannelFeatures *NONNULL_PTR orig);
10661
10662 /**
10663  * Creates a copy of the InvoiceFeatures
10664  */
10665 struct LDKInvoiceFeatures InvoiceFeatures_clone(const struct LDKInvoiceFeatures *NONNULL_PTR orig);
10666
10667 /**
10668  * Frees any resources used by the InitFeatures, if is_owned is set and inner is non-NULL.
10669  */
10670 void InitFeatures_free(struct LDKInitFeatures this_obj);
10671
10672 /**
10673  * Frees any resources used by the NodeFeatures, if is_owned is set and inner is non-NULL.
10674  */
10675 void NodeFeatures_free(struct LDKNodeFeatures this_obj);
10676
10677 /**
10678  * Frees any resources used by the ChannelFeatures, if is_owned is set and inner is non-NULL.
10679  */
10680 void ChannelFeatures_free(struct LDKChannelFeatures this_obj);
10681
10682 /**
10683  * Frees any resources used by the InvoiceFeatures, if is_owned is set and inner is non-NULL.
10684  */
10685 void InvoiceFeatures_free(struct LDKInvoiceFeatures this_obj);
10686
10687 /**
10688  * Create a blank Features with no features set
10689  */
10690 MUST_USE_RES struct LDKInitFeatures InitFeatures_empty(void);
10691
10692 /**
10693  * Creates a Features with the bits set which are known by the implementation
10694  */
10695 MUST_USE_RES struct LDKInitFeatures InitFeatures_known(void);
10696
10697 /**
10698  * Create a blank Features with no features set
10699  */
10700 MUST_USE_RES struct LDKNodeFeatures NodeFeatures_empty(void);
10701
10702 /**
10703  * Creates a Features with the bits set which are known by the implementation
10704  */
10705 MUST_USE_RES struct LDKNodeFeatures NodeFeatures_known(void);
10706
10707 /**
10708  * Create a blank Features with no features set
10709  */
10710 MUST_USE_RES struct LDKChannelFeatures ChannelFeatures_empty(void);
10711
10712 /**
10713  * Creates a Features with the bits set which are known by the implementation
10714  */
10715 MUST_USE_RES struct LDKChannelFeatures ChannelFeatures_known(void);
10716
10717 /**
10718  * Create a blank Features with no features set
10719  */
10720 MUST_USE_RES struct LDKInvoiceFeatures InvoiceFeatures_empty(void);
10721
10722 /**
10723  * Creates a Features with the bits set which are known by the implementation
10724  */
10725 MUST_USE_RES struct LDKInvoiceFeatures InvoiceFeatures_known(void);
10726
10727 /**
10728  * Serialize the InitFeatures object into a byte array which can be read by InitFeatures_read
10729  */
10730 struct LDKCVec_u8Z InitFeatures_write(const struct LDKInitFeatures *NONNULL_PTR obj);
10731
10732 /**
10733  * Serialize the NodeFeatures object into a byte array which can be read by NodeFeatures_read
10734  */
10735 struct LDKCVec_u8Z NodeFeatures_write(const struct LDKNodeFeatures *NONNULL_PTR obj);
10736
10737 /**
10738  * Serialize the ChannelFeatures object into a byte array which can be read by ChannelFeatures_read
10739  */
10740 struct LDKCVec_u8Z ChannelFeatures_write(const struct LDKChannelFeatures *NONNULL_PTR obj);
10741
10742 /**
10743  * Serialize the InvoiceFeatures object into a byte array which can be read by InvoiceFeatures_read
10744  */
10745 struct LDKCVec_u8Z InvoiceFeatures_write(const struct LDKInvoiceFeatures *NONNULL_PTR obj);
10746
10747 /**
10748  * Read a InitFeatures from a byte array, created by InitFeatures_write
10749  */
10750 struct LDKCResult_InitFeaturesDecodeErrorZ InitFeatures_read(struct LDKu8slice ser);
10751
10752 /**
10753  * Read a NodeFeatures from a byte array, created by NodeFeatures_write
10754  */
10755 struct LDKCResult_NodeFeaturesDecodeErrorZ NodeFeatures_read(struct LDKu8slice ser);
10756
10757 /**
10758  * Read a ChannelFeatures from a byte array, created by ChannelFeatures_write
10759  */
10760 struct LDKCResult_ChannelFeaturesDecodeErrorZ ChannelFeatures_read(struct LDKu8slice ser);
10761
10762 /**
10763  * Read a InvoiceFeatures from a byte array, created by InvoiceFeatures_write
10764  */
10765 struct LDKCResult_InvoiceFeaturesDecodeErrorZ InvoiceFeatures_read(struct LDKu8slice ser);
10766
10767 /**
10768  * Frees any resources used by the RouteHop, if is_owned is set and inner is non-NULL.
10769  */
10770 void RouteHop_free(struct LDKRouteHop this_obj);
10771
10772 /**
10773  * The node_id of the node at this hop.
10774  */
10775 struct LDKPublicKey RouteHop_get_pubkey(const struct LDKRouteHop *NONNULL_PTR this_ptr);
10776
10777 /**
10778  * The node_id of the node at this hop.
10779  */
10780 void RouteHop_set_pubkey(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
10781
10782 /**
10783  * The node_announcement features of the node at this hop. For the last hop, these may be
10784  * amended to match the features present in the invoice this node generated.
10785  */
10786 struct LDKNodeFeatures RouteHop_get_node_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
10787
10788 /**
10789  * The node_announcement features of the node at this hop. For the last hop, these may be
10790  * amended to match the features present in the invoice this node generated.
10791  */
10792 void RouteHop_set_node_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
10793
10794 /**
10795  * The channel that should be used from the previous hop to reach this node.
10796  */
10797 uint64_t RouteHop_get_short_channel_id(const struct LDKRouteHop *NONNULL_PTR this_ptr);
10798
10799 /**
10800  * The channel that should be used from the previous hop to reach this node.
10801  */
10802 void RouteHop_set_short_channel_id(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
10803
10804 /**
10805  * The channel_announcement features of the channel that should be used from the previous hop
10806  * to reach this node.
10807  */
10808 struct LDKChannelFeatures RouteHop_get_channel_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
10809
10810 /**
10811  * The channel_announcement features of the channel that should be used from the previous hop
10812  * to reach this node.
10813  */
10814 void RouteHop_set_channel_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
10815
10816 /**
10817  * The fee taken on this hop (for paying for the use of the *next* channel in the path).
10818  * For the last hop, this should be the full value of the payment (might be more than
10819  * requested if we had to match htlc_minimum_msat).
10820  */
10821 uint64_t RouteHop_get_fee_msat(const struct LDKRouteHop *NONNULL_PTR this_ptr);
10822
10823 /**
10824  * The fee taken on this hop (for paying for the use of the *next* channel in the path).
10825  * For the last hop, this should be the full value of the payment (might be more than
10826  * requested if we had to match htlc_minimum_msat).
10827  */
10828 void RouteHop_set_fee_msat(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
10829
10830 /**
10831  * The CLTV delta added for this hop. For the last hop, this should be the full CLTV value
10832  * expected at the destination, in excess of the current block height.
10833  */
10834 uint32_t RouteHop_get_cltv_expiry_delta(const struct LDKRouteHop *NONNULL_PTR this_ptr);
10835
10836 /**
10837  * The CLTV delta added for this hop. For the last hop, this should be the full CLTV value
10838  * expected at the destination, in excess of the current block height.
10839  */
10840 void RouteHop_set_cltv_expiry_delta(struct LDKRouteHop *NONNULL_PTR this_ptr, uint32_t val);
10841
10842 /**
10843  * Constructs a new RouteHop given each field
10844  */
10845 MUST_USE_RES struct LDKRouteHop RouteHop_new(struct LDKPublicKey pubkey_arg, struct LDKNodeFeatures node_features_arg, uint64_t short_channel_id_arg, struct LDKChannelFeatures channel_features_arg, uint64_t fee_msat_arg, uint32_t cltv_expiry_delta_arg);
10846
10847 /**
10848  * Creates a copy of the RouteHop
10849  */
10850 struct LDKRouteHop RouteHop_clone(const struct LDKRouteHop *NONNULL_PTR orig);
10851
10852 /**
10853  * Frees any resources used by the Route, if is_owned is set and inner is non-NULL.
10854  */
10855 void Route_free(struct LDKRoute this_obj);
10856
10857 /**
10858  * The list of routes taken for a single (potentially-)multi-part payment. The pubkey of the
10859  * last RouteHop in each path must be the same.
10860  * Each entry represents a list of hops, NOT INCLUDING our own, where the last hop is the
10861  * destination. Thus, this must always be at least length one. While the maximum length of any
10862  * given path is variable, keeping the length of any path to less than 20 should currently
10863  * ensure it is viable.
10864  */
10865 void Route_set_paths(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKCVec_CVec_RouteHopZZ val);
10866
10867 /**
10868  * Constructs a new Route given each field
10869  */
10870 MUST_USE_RES struct LDKRoute Route_new(struct LDKCVec_CVec_RouteHopZZ paths_arg);
10871
10872 /**
10873  * Creates a copy of the Route
10874  */
10875 struct LDKRoute Route_clone(const struct LDKRoute *NONNULL_PTR orig);
10876
10877 /**
10878  * Serialize the Route object into a byte array which can be read by Route_read
10879  */
10880 struct LDKCVec_u8Z Route_write(const struct LDKRoute *NONNULL_PTR obj);
10881
10882 /**
10883  * Read a Route from a byte array, created by Route_write
10884  */
10885 struct LDKCResult_RouteDecodeErrorZ Route_read(struct LDKu8slice ser);
10886
10887 /**
10888  * Frees any resources used by the RouteHint, if is_owned is set and inner is non-NULL.
10889  */
10890 void RouteHint_free(struct LDKRouteHint this_obj);
10891
10892 /**
10893  * The node_id of the non-target end of the route
10894  */
10895 struct LDKPublicKey RouteHint_get_src_node_id(const struct LDKRouteHint *NONNULL_PTR this_ptr);
10896
10897 /**
10898  * The node_id of the non-target end of the route
10899  */
10900 void RouteHint_set_src_node_id(struct LDKRouteHint *NONNULL_PTR this_ptr, struct LDKPublicKey val);
10901
10902 /**
10903  * The short_channel_id of this channel
10904  */
10905 uint64_t RouteHint_get_short_channel_id(const struct LDKRouteHint *NONNULL_PTR this_ptr);
10906
10907 /**
10908  * The short_channel_id of this channel
10909  */
10910 void RouteHint_set_short_channel_id(struct LDKRouteHint *NONNULL_PTR this_ptr, uint64_t val);
10911
10912 /**
10913  * The fees which must be paid to use this channel
10914  */
10915 struct LDKRoutingFees RouteHint_get_fees(const struct LDKRouteHint *NONNULL_PTR this_ptr);
10916
10917 /**
10918  * The fees which must be paid to use this channel
10919  */
10920 void RouteHint_set_fees(struct LDKRouteHint *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
10921
10922 /**
10923  * The difference in CLTV values between this node and the next node.
10924  */
10925 uint16_t RouteHint_get_cltv_expiry_delta(const struct LDKRouteHint *NONNULL_PTR this_ptr);
10926
10927 /**
10928  * The difference in CLTV values between this node and the next node.
10929  */
10930 void RouteHint_set_cltv_expiry_delta(struct LDKRouteHint *NONNULL_PTR this_ptr, uint16_t val);
10931
10932 /**
10933  * Creates a copy of the RouteHint
10934  */
10935 struct LDKRouteHint RouteHint_clone(const struct LDKRouteHint *NONNULL_PTR orig);
10936
10937 /**
10938  * Gets a route from us (payer) to the given target node (payee).
10939  *
10940  * If the payee provided features in their invoice, they should be provided via payee_features.
10941  * Without this, MPP will only be used if the payee's features are available in the network graph.
10942  *
10943  * Extra routing hops between known nodes and the target will be used if they are included in
10944  * last_hops.
10945  *
10946  * If some channels aren't announced, it may be useful to fill in a first_hops with the
10947  * results from a local ChannelManager::list_usable_channels() call. If it is filled in, our
10948  * view of our local channels (from net_graph_msg_handler) will be ignored, and only those
10949  * in first_hops will be used.
10950  *
10951  * Panics if first_hops contains channels without short_channel_ids
10952  * (ChannelManager::list_usable_channels will never include such channels).
10953  *
10954  * The fees on channels from us to next-hops are ignored (as they are assumed to all be
10955  * equal), however the enabled/disabled bit on such channels as well as the
10956  * htlc_minimum_msat/htlc_maximum_msat *are* checked as they may change based on the receiving node.
10957  */
10958 struct LDKCResult_RouteLightningErrorZ get_route(struct LDKPublicKey our_node_id, const struct LDKNetworkGraph *NONNULL_PTR network, struct LDKPublicKey payee, struct LDKInvoiceFeatures payee_features, struct LDKCVec_ChannelDetailsZ *first_hops, struct LDKCVec_RouteHintZ last_hops, uint64_t final_value_msat, uint32_t final_cltv, struct LDKLogger logger);
10959
10960 /**
10961  * Frees any resources used by the NetworkGraph, if is_owned is set and inner is non-NULL.
10962  */
10963 void NetworkGraph_free(struct LDKNetworkGraph this_obj);
10964
10965 /**
10966  * Creates a copy of the NetworkGraph
10967  */
10968 struct LDKNetworkGraph NetworkGraph_clone(const struct LDKNetworkGraph *NONNULL_PTR orig);
10969
10970 /**
10971  * Frees any resources used by the LockedNetworkGraph, if is_owned is set and inner is non-NULL.
10972  */
10973 void LockedNetworkGraph_free(struct LDKLockedNetworkGraph this_obj);
10974
10975 /**
10976  * Frees any resources used by the NetGraphMsgHandler, if is_owned is set and inner is non-NULL.
10977  */
10978 void NetGraphMsgHandler_free(struct LDKNetGraphMsgHandler this_obj);
10979
10980 /**
10981  * Creates a new tracker of the actual state of the network of channels and nodes,
10982  * assuming a fresh network graph.
10983  * Chain monitor is used to make sure announced channels exist on-chain,
10984  * channel data is correct, and that the announcement is signed with
10985  * channel owners' keys.
10986  */
10987 MUST_USE_RES struct LDKNetGraphMsgHandler NetGraphMsgHandler_new(struct LDKThirtyTwoBytes genesis_hash, struct LDKAccess *chain_access, struct LDKLogger logger);
10988
10989 /**
10990  * Creates a new tracker of the actual state of the network of channels and nodes,
10991  * assuming an existing Network Graph.
10992  */
10993 MUST_USE_RES struct LDKNetGraphMsgHandler NetGraphMsgHandler_from_net_graph(struct LDKAccess *chain_access, struct LDKLogger logger, struct LDKNetworkGraph network_graph);
10994
10995 /**
10996  * Adds a provider used to check new announcements. Does not affect
10997  * existing announcements unless they are updated.
10998  * Add, update or remove the provider would replace the current one.
10999  */
11000 void NetGraphMsgHandler_add_chain_access(struct LDKNetGraphMsgHandler *NONNULL_PTR this_arg, struct LDKAccess *chain_access);
11001
11002 /**
11003  * Take a read lock on the network_graph and return it in the C-bindings
11004  * newtype helper. This is likely only useful when called via the C
11005  * bindings as you can call `self.network_graph.read().unwrap()` in Rust
11006  * yourself.
11007  */
11008 MUST_USE_RES struct LDKLockedNetworkGraph NetGraphMsgHandler_read_locked_graph(const struct LDKNetGraphMsgHandler *NONNULL_PTR this_arg);
11009
11010 /**
11011  * Get a reference to the NetworkGraph which this read-lock contains.
11012  */
11013 MUST_USE_RES struct LDKNetworkGraph LockedNetworkGraph_graph(const struct LDKLockedNetworkGraph *NONNULL_PTR this_arg);
11014
11015 /**
11016  * Constructs a new RoutingMessageHandler which calls the relevant methods on this_arg.
11017  * This copies the `inner` pointer in this_arg and thus the returned RoutingMessageHandler must be freed before this_arg is
11018  */
11019 struct LDKRoutingMessageHandler NetGraphMsgHandler_as_RoutingMessageHandler(const struct LDKNetGraphMsgHandler *NONNULL_PTR this_arg);
11020
11021 /**
11022  * Constructs a new MessageSendEventsProvider which calls the relevant methods on this_arg.
11023  * This copies the `inner` pointer in this_arg and thus the returned MessageSendEventsProvider must be freed before this_arg is
11024  */
11025 struct LDKMessageSendEventsProvider NetGraphMsgHandler_as_MessageSendEventsProvider(const struct LDKNetGraphMsgHandler *NONNULL_PTR this_arg);
11026
11027 /**
11028  * Frees any resources used by the DirectionalChannelInfo, if is_owned is set and inner is non-NULL.
11029  */
11030 void DirectionalChannelInfo_free(struct LDKDirectionalChannelInfo this_obj);
11031
11032 /**
11033  * When the last update to the channel direction was issued.
11034  * Value is opaque, as set in the announcement.
11035  */
11036 uint32_t DirectionalChannelInfo_get_last_update(const struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr);
11037
11038 /**
11039  * When the last update to the channel direction was issued.
11040  * Value is opaque, as set in the announcement.
11041  */
11042 void DirectionalChannelInfo_set_last_update(struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr, uint32_t val);
11043
11044 /**
11045  * Whether the channel can be currently used for payments (in this one direction).
11046  */
11047 bool DirectionalChannelInfo_get_enabled(const struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr);
11048
11049 /**
11050  * Whether the channel can be currently used for payments (in this one direction).
11051  */
11052 void DirectionalChannelInfo_set_enabled(struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr, bool val);
11053
11054 /**
11055  * The difference in CLTV values that you must have when routing through this channel.
11056  */
11057 uint16_t DirectionalChannelInfo_get_cltv_expiry_delta(const struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr);
11058
11059 /**
11060  * The difference in CLTV values that you must have when routing through this channel.
11061  */
11062 void DirectionalChannelInfo_set_cltv_expiry_delta(struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr, uint16_t val);
11063
11064 /**
11065  * The minimum value, which must be relayed to the next hop via the channel
11066  */
11067 uint64_t DirectionalChannelInfo_get_htlc_minimum_msat(const struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr);
11068
11069 /**
11070  * The minimum value, which must be relayed to the next hop via the channel
11071  */
11072 void DirectionalChannelInfo_set_htlc_minimum_msat(struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr, uint64_t val);
11073
11074 /**
11075  * Fees charged when the channel is used for routing
11076  */
11077 struct LDKRoutingFees DirectionalChannelInfo_get_fees(const struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr);
11078
11079 /**
11080  * Fees charged when the channel is used for routing
11081  */
11082 void DirectionalChannelInfo_set_fees(struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
11083
11084 /**
11085  * Most recent update for the channel received from the network
11086  * Mostly redundant with the data we store in fields explicitly.
11087  * Everything else is useful only for sending out for initial routing sync.
11088  * Not stored if contains excess data to prevent DoS.
11089  */
11090 struct LDKChannelUpdate DirectionalChannelInfo_get_last_update_message(const struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr);
11091
11092 /**
11093  * Most recent update for the channel received from the network
11094  * Mostly redundant with the data we store in fields explicitly.
11095  * Everything else is useful only for sending out for initial routing sync.
11096  * Not stored if contains excess data to prevent DoS.
11097  */
11098 void DirectionalChannelInfo_set_last_update_message(struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdate val);
11099
11100 /**
11101  * Creates a copy of the DirectionalChannelInfo
11102  */
11103 struct LDKDirectionalChannelInfo DirectionalChannelInfo_clone(const struct LDKDirectionalChannelInfo *NONNULL_PTR orig);
11104
11105 /**
11106  * Serialize the DirectionalChannelInfo object into a byte array which can be read by DirectionalChannelInfo_read
11107  */
11108 struct LDKCVec_u8Z DirectionalChannelInfo_write(const struct LDKDirectionalChannelInfo *NONNULL_PTR obj);
11109
11110 /**
11111  * Read a DirectionalChannelInfo from a byte array, created by DirectionalChannelInfo_write
11112  */
11113 struct LDKCResult_DirectionalChannelInfoDecodeErrorZ DirectionalChannelInfo_read(struct LDKu8slice ser);
11114
11115 /**
11116  * Frees any resources used by the ChannelInfo, if is_owned is set and inner is non-NULL.
11117  */
11118 void ChannelInfo_free(struct LDKChannelInfo this_obj);
11119
11120 /**
11121  * Protocol features of a channel communicated during its announcement
11122  */
11123 struct LDKChannelFeatures ChannelInfo_get_features(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
11124
11125 /**
11126  * Protocol features of a channel communicated during its announcement
11127  */
11128 void ChannelInfo_set_features(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
11129
11130 /**
11131  * Source node of the first direction of a channel
11132  */
11133 struct LDKPublicKey ChannelInfo_get_node_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
11134
11135 /**
11136  * Source node of the first direction of a channel
11137  */
11138 void ChannelInfo_set_node_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKPublicKey val);
11139
11140 /**
11141  * Details about the first direction of a channel
11142  */
11143 struct LDKDirectionalChannelInfo ChannelInfo_get_one_to_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
11144
11145 /**
11146  * Details about the first direction of a channel
11147  */
11148 void ChannelInfo_set_one_to_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKDirectionalChannelInfo val);
11149
11150 /**
11151  * Source node of the second direction of a channel
11152  */
11153 struct LDKPublicKey ChannelInfo_get_node_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
11154
11155 /**
11156  * Source node of the second direction of a channel
11157  */
11158 void ChannelInfo_set_node_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKPublicKey val);
11159
11160 /**
11161  * Details about the second direction of a channel
11162  */
11163 struct LDKDirectionalChannelInfo ChannelInfo_get_two_to_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
11164
11165 /**
11166  * Details about the second direction of a channel
11167  */
11168 void ChannelInfo_set_two_to_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKDirectionalChannelInfo val);
11169
11170 /**
11171  * An initial announcement of the channel
11172  * Mostly redundant with the data we store in fields explicitly.
11173  * Everything else is useful only for sending out for initial routing sync.
11174  * Not stored if contains excess data to prevent DoS.
11175  */
11176 struct LDKChannelAnnouncement ChannelInfo_get_announcement_message(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
11177
11178 /**
11179  * An initial announcement of the channel
11180  * Mostly redundant with the data we store in fields explicitly.
11181  * Everything else is useful only for sending out for initial routing sync.
11182  * Not stored if contains excess data to prevent DoS.
11183  */
11184 void ChannelInfo_set_announcement_message(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelAnnouncement val);
11185
11186 /**
11187  * Creates a copy of the ChannelInfo
11188  */
11189 struct LDKChannelInfo ChannelInfo_clone(const struct LDKChannelInfo *NONNULL_PTR orig);
11190
11191 /**
11192  * Serialize the ChannelInfo object into a byte array which can be read by ChannelInfo_read
11193  */
11194 struct LDKCVec_u8Z ChannelInfo_write(const struct LDKChannelInfo *NONNULL_PTR obj);
11195
11196 /**
11197  * Read a ChannelInfo from a byte array, created by ChannelInfo_write
11198  */
11199 struct LDKCResult_ChannelInfoDecodeErrorZ ChannelInfo_read(struct LDKu8slice ser);
11200
11201 /**
11202  * Frees any resources used by the RoutingFees, if is_owned is set and inner is non-NULL.
11203  */
11204 void RoutingFees_free(struct LDKRoutingFees this_obj);
11205
11206 /**
11207  * Flat routing fee in satoshis
11208  */
11209 uint32_t RoutingFees_get_base_msat(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
11210
11211 /**
11212  * Flat routing fee in satoshis
11213  */
11214 void RoutingFees_set_base_msat(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
11215
11216 /**
11217  * Liquidity-based routing fee in millionths of a routed amount.
11218  * In other words, 10000 is 1%.
11219  */
11220 uint32_t RoutingFees_get_proportional_millionths(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
11221
11222 /**
11223  * Liquidity-based routing fee in millionths of a routed amount.
11224  * In other words, 10000 is 1%.
11225  */
11226 void RoutingFees_set_proportional_millionths(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
11227
11228 /**
11229  * Constructs a new RoutingFees given each field
11230  */
11231 MUST_USE_RES struct LDKRoutingFees RoutingFees_new(uint32_t base_msat_arg, uint32_t proportional_millionths_arg);
11232
11233 /**
11234  * Creates a copy of the RoutingFees
11235  */
11236 struct LDKRoutingFees RoutingFees_clone(const struct LDKRoutingFees *NONNULL_PTR orig);
11237
11238 /**
11239  * Read a RoutingFees from a byte array, created by RoutingFees_write
11240  */
11241 struct LDKCResult_RoutingFeesDecodeErrorZ RoutingFees_read(struct LDKu8slice ser);
11242
11243 /**
11244  * Serialize the RoutingFees object into a byte array which can be read by RoutingFees_read
11245  */
11246 struct LDKCVec_u8Z RoutingFees_write(const struct LDKRoutingFees *NONNULL_PTR obj);
11247
11248 /**
11249  * Frees any resources used by the NodeAnnouncementInfo, if is_owned is set and inner is non-NULL.
11250  */
11251 void NodeAnnouncementInfo_free(struct LDKNodeAnnouncementInfo this_obj);
11252
11253 /**
11254  * Protocol features the node announced support for
11255  */
11256 struct LDKNodeFeatures NodeAnnouncementInfo_get_features(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
11257
11258 /**
11259  * Protocol features the node announced support for
11260  */
11261 void NodeAnnouncementInfo_set_features(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
11262
11263 /**
11264  * When the last known update to the node state was issued.
11265  * Value is opaque, as set in the announcement.
11266  */
11267 uint32_t NodeAnnouncementInfo_get_last_update(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
11268
11269 /**
11270  * When the last known update to the node state was issued.
11271  * Value is opaque, as set in the announcement.
11272  */
11273 void NodeAnnouncementInfo_set_last_update(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, uint32_t val);
11274
11275 /**
11276  * Color assigned to the node
11277  */
11278 const uint8_t (*NodeAnnouncementInfo_get_rgb(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr))[3];
11279
11280 /**
11281  * Color assigned to the node
11282  */
11283 void NodeAnnouncementInfo_set_rgb(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
11284
11285 /**
11286  * Moniker assigned to the node.
11287  * May be invalid or malicious (eg control chars),
11288  * should not be exposed to the user.
11289  */
11290 const uint8_t (*NodeAnnouncementInfo_get_alias(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr))[32];
11291
11292 /**
11293  * Moniker assigned to the node.
11294  * May be invalid or malicious (eg control chars),
11295  * should not be exposed to the user.
11296  */
11297 void NodeAnnouncementInfo_set_alias(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
11298
11299 /**
11300  * Internet-level addresses via which one can connect to the node
11301  */
11302 void NodeAnnouncementInfo_set_addresses(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKCVec_NetAddressZ val);
11303
11304 /**
11305  * An initial announcement of the node
11306  * Mostly redundant with the data we store in fields explicitly.
11307  * Everything else is useful only for sending out for initial routing sync.
11308  * Not stored if contains excess data to prevent DoS.
11309  */
11310 struct LDKNodeAnnouncement NodeAnnouncementInfo_get_announcement_message(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
11311
11312 /**
11313  * An initial announcement of the node
11314  * Mostly redundant with the data we store in fields explicitly.
11315  * Everything else is useful only for sending out for initial routing sync.
11316  * Not stored if contains excess data to prevent DoS.
11317  */
11318 void NodeAnnouncementInfo_set_announcement_message(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncement val);
11319
11320 /**
11321  * Constructs a new NodeAnnouncementInfo given each field
11322  */
11323 MUST_USE_RES struct LDKNodeAnnouncementInfo NodeAnnouncementInfo_new(struct LDKNodeFeatures features_arg, uint32_t last_update_arg, struct LDKThreeBytes rgb_arg, struct LDKThirtyTwoBytes alias_arg, struct LDKCVec_NetAddressZ addresses_arg, struct LDKNodeAnnouncement announcement_message_arg);
11324
11325 /**
11326  * Creates a copy of the NodeAnnouncementInfo
11327  */
11328 struct LDKNodeAnnouncementInfo NodeAnnouncementInfo_clone(const struct LDKNodeAnnouncementInfo *NONNULL_PTR orig);
11329
11330 /**
11331  * Serialize the NodeAnnouncementInfo object into a byte array which can be read by NodeAnnouncementInfo_read
11332  */
11333 struct LDKCVec_u8Z NodeAnnouncementInfo_write(const struct LDKNodeAnnouncementInfo *NONNULL_PTR obj);
11334
11335 /**
11336  * Read a NodeAnnouncementInfo from a byte array, created by NodeAnnouncementInfo_write
11337  */
11338 struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ NodeAnnouncementInfo_read(struct LDKu8slice ser);
11339
11340 /**
11341  * Frees any resources used by the NodeInfo, if is_owned is set and inner is non-NULL.
11342  */
11343 void NodeInfo_free(struct LDKNodeInfo this_obj);
11344
11345 /**
11346  * All valid channels a node has announced
11347  */
11348 void NodeInfo_set_channels(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
11349
11350 /**
11351  * Lowest fees enabling routing via any of the enabled, known channels to a node.
11352  * The two fields (flat and proportional fee) are independent,
11353  * meaning they don't have to refer to the same channel.
11354  */
11355 struct LDKRoutingFees NodeInfo_get_lowest_inbound_channel_fees(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
11356
11357 /**
11358  * Lowest fees enabling routing via any of the enabled, known channels to a node.
11359  * The two fields (flat and proportional fee) are independent,
11360  * meaning they don't have to refer to the same channel.
11361  */
11362 void NodeInfo_set_lowest_inbound_channel_fees(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
11363
11364 /**
11365  * More information about a node from node_announcement.
11366  * Optional because we store a Node entry after learning about it from
11367  * a channel announcement, but before receiving a node announcement.
11368  */
11369 struct LDKNodeAnnouncementInfo NodeInfo_get_announcement_info(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
11370
11371 /**
11372  * More information about a node from node_announcement.
11373  * Optional because we store a Node entry after learning about it from
11374  * a channel announcement, but before receiving a node announcement.
11375  */
11376 void NodeInfo_set_announcement_info(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncementInfo val);
11377
11378 /**
11379  * Constructs a new NodeInfo given each field
11380  */
11381 MUST_USE_RES struct LDKNodeInfo NodeInfo_new(struct LDKCVec_u64Z channels_arg, struct LDKRoutingFees lowest_inbound_channel_fees_arg, struct LDKNodeAnnouncementInfo announcement_info_arg);
11382
11383 /**
11384  * Creates a copy of the NodeInfo
11385  */
11386 struct LDKNodeInfo NodeInfo_clone(const struct LDKNodeInfo *NONNULL_PTR orig);
11387
11388 /**
11389  * Serialize the NodeInfo object into a byte array which can be read by NodeInfo_read
11390  */
11391 struct LDKCVec_u8Z NodeInfo_write(const struct LDKNodeInfo *NONNULL_PTR obj);
11392
11393 /**
11394  * Read a NodeInfo from a byte array, created by NodeInfo_write
11395  */
11396 struct LDKCResult_NodeInfoDecodeErrorZ NodeInfo_read(struct LDKu8slice ser);
11397
11398 /**
11399  * Serialize the NetworkGraph object into a byte array which can be read by NetworkGraph_read
11400  */
11401 struct LDKCVec_u8Z NetworkGraph_write(const struct LDKNetworkGraph *NONNULL_PTR obj);
11402
11403 /**
11404  * Read a NetworkGraph from a byte array, created by NetworkGraph_write
11405  */
11406 struct LDKCResult_NetworkGraphDecodeErrorZ NetworkGraph_read(struct LDKu8slice ser);
11407
11408 /**
11409  * Creates a new, empty, network graph.
11410  */
11411 MUST_USE_RES struct LDKNetworkGraph NetworkGraph_new(struct LDKThirtyTwoBytes genesis_hash);
11412
11413 /**
11414  * For an already known node (from channel announcements), update its stored properties from a
11415  * given node announcement.
11416  *
11417  * You probably don't want to call this directly, instead relying on a NetGraphMsgHandler's
11418  * RoutingMessageHandler implementation to call it indirectly. This may be useful to accept
11419  * routing messages from a source using a protocol other than the lightning P2P protocol.
11420  */
11421 MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_node_from_announcement(struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg);
11422
11423 /**
11424  * For an already known node (from channel announcements), update its stored properties from a
11425  * given node announcement without verifying the associated signatures. Because we aren't
11426  * given the associated signatures here we cannot relay the node announcement to any of our
11427  * peers.
11428  */
11429 MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_node_from_unsigned_announcement(struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR msg);
11430
11431 /**
11432  * Store or update channel info from a channel announcement.
11433  *
11434  * You probably don't want to call this directly, instead relying on a NetGraphMsgHandler's
11435  * RoutingMessageHandler implementation to call it indirectly. This may be useful to accept
11436  * routing messages from a source using a protocol other than the lightning P2P protocol.
11437  *
11438  * If a `chain::Access` object is provided via `chain_access`, it will be called to verify
11439  * the corresponding UTXO exists on chain and is correctly-formatted.
11440  */
11441 MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel_from_announcement(struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKChannelAnnouncement *NONNULL_PTR msg, struct LDKAccess *chain_access);
11442
11443 /**
11444  * Store or update channel info from a channel announcement without verifying the associated
11445  * signatures. Because we aren't given the associated signatures here we cannot relay the
11446  * channel announcement to any of our peers.
11447  *
11448  * If a `chain::Access` object is provided via `chain_access`, it will be called to verify
11449  * the corresponding UTXO exists on chain and is correctly-formatted.
11450  */
11451 MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel_from_unsigned_announcement(struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg, struct LDKAccess *chain_access);
11452
11453 /**
11454  * Close a channel if a corresponding HTLC fail was sent.
11455  * If permanent, removes a channel from the local storage.
11456  * May cause the removal of nodes too, if this was their last channel.
11457  * If not permanent, makes channels unavailable for routing.
11458  */
11459 void NetworkGraph_close_channel_from_update(struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id, bool is_permanent);
11460
11461 /**
11462  * For an already known (from announcement) channel, update info about one of the directions
11463  * of the channel.
11464  *
11465  * You probably don't want to call this directly, instead relying on a NetGraphMsgHandler's
11466  * RoutingMessageHandler implementation to call it indirectly. This may be useful to accept
11467  * routing messages from a source using a protocol other than the lightning P2P protocol.
11468  */
11469 MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel(struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg);
11470
11471 /**
11472  * For an already known (from announcement) channel, update info about one of the directions
11473  * of the channel without verifying the associated signatures. Because we aren't given the
11474  * associated signatures here we cannot relay the channel update to any of our peers.
11475  */
11476 MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel_unsigned(struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKUnsignedChannelUpdate *NONNULL_PTR msg);
11477
11478 /* Text to put at the end of the generated file */