_ 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 uintptr_t REVOKEABLE_REDEEMSCRIPT_MAX_LENGTH;
4963
4964 void Transaction_free(struct LDKTransaction _res);
4965
4966 void TxOut_free(struct LDKTxOut _res);
4967
4968 struct LDKTxOut TxOut_clone(const struct LDKTxOut *NONNULL_PTR orig);
4969
4970 struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_ok(struct LDKSecretKey o);
4971
4972 struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_err(enum LDKSecp256k1Error e);
4973
4974 void CResult_SecretKeyErrorZ_free(struct LDKCResult_SecretKeyErrorZ _res);
4975
4976 struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_ok(struct LDKPublicKey o);
4977
4978 struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_err(enum LDKSecp256k1Error e);
4979
4980 void CResult_PublicKeyErrorZ_free(struct LDKCResult_PublicKeyErrorZ _res);
4981
4982 struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_ok(struct LDKTxCreationKeys o);
4983
4984 struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_err(struct LDKDecodeError e);
4985
4986 void CResult_TxCreationKeysDecodeErrorZ_free(struct LDKCResult_TxCreationKeysDecodeErrorZ _res);
4987
4988 struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_clone(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR orig);
4989
4990 struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_ok(struct LDKChannelPublicKeys o);
4991
4992 struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_err(struct LDKDecodeError e);
4993
4994 void CResult_ChannelPublicKeysDecodeErrorZ_free(struct LDKCResult_ChannelPublicKeysDecodeErrorZ _res);
4995
4996 struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_clone(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR orig);
4997
4998 struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_ok(struct LDKTxCreationKeys o);
4999
5000 struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_err(enum LDKSecp256k1Error e);
5001
5002 void CResult_TxCreationKeysErrorZ_free(struct LDKCResult_TxCreationKeysErrorZ _res);
5003
5004 struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(struct LDKHTLCOutputInCommitment o);
5005
5006 struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_err(struct LDKDecodeError e);
5007
5008 void CResult_HTLCOutputInCommitmentDecodeErrorZ_free(struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ _res);
5009
5010 struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR orig);
5011
5012 struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(struct LDKCounterpartyChannelTransactionParameters o);
5013
5014 struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
5015
5016 void CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ _res);
5017
5018 struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
5019
5020 struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_ok(struct LDKChannelTransactionParameters o);
5021
5022 struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
5023
5024 void CResult_ChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_ChannelTransactionParametersDecodeErrorZ _res);
5025
5026 struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
5027
5028 void CVec_SignatureZ_free(struct LDKCVec_SignatureZ _res);
5029
5030 struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_ok(struct LDKHolderCommitmentTransaction o);
5031
5032 struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
5033
5034 void CResult_HolderCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ _res);
5035
5036 struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
5037
5038 struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(struct LDKBuiltCommitmentTransaction o);
5039
5040 struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
5041
5042 void CResult_BuiltCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ _res);
5043
5044 struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
5045
5046 struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_ok(struct LDKCommitmentTransaction o);
5047
5048 struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
5049
5050 void CResult_CommitmentTransactionDecodeErrorZ_free(struct LDKCResult_CommitmentTransactionDecodeErrorZ _res);
5051
5052 struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
5053
5054 struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_ok(struct LDKTrustedCommitmentTransaction o);
5055
5056 struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_err(void);
5057
5058 void CResult_TrustedCommitmentTransactionNoneZ_free(struct LDKCResult_TrustedCommitmentTransactionNoneZ _res);
5059
5060 struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_ok(struct LDKCVec_SignatureZ o);
5061
5062 struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_err(void);
5063
5064 void CResult_CVec_SignatureZNoneZ_free(struct LDKCResult_CVec_SignatureZNoneZ _res);
5065
5066 struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_clone(const struct LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR orig);
5067
5068 void CVec_MessageSendEventZ_free(struct LDKCVec_MessageSendEventZ _res);
5069
5070 struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_ok(bool o);
5071
5072 struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_err(struct LDKLightningError e);
5073
5074 void CResult_boolLightningErrorZ_free(struct LDKCResult_boolLightningErrorZ _res);
5075
5076 struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_clone(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR orig);
5077
5078 struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(const struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR orig);
5079
5080 struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(struct LDKChannelAnnouncement a, struct LDKChannelUpdate b, struct LDKChannelUpdate c);
5081
5082 void C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res);
5083
5084 void CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(struct LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res);
5085
5086 void CVec_NodeAnnouncementZ_free(struct LDKCVec_NodeAnnouncementZ _res);
5087
5088 struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_ok(void);
5089
5090 struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_err(struct LDKLightningError e);
5091
5092 void CResult_NoneLightningErrorZ_free(struct LDKCResult_NoneLightningErrorZ _res);
5093
5094 struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_clone(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR orig);
5095
5096 void CVec_PublicKeyZ_free(struct LDKCVec_PublicKeyZ _res);
5097
5098 void CVec_u8Z_free(struct LDKCVec_u8Z _res);
5099
5100 struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_ok(struct LDKCVec_u8Z o);
5101
5102 struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_err(struct LDKPeerHandleError e);
5103
5104 void CResult_CVec_u8ZPeerHandleErrorZ_free(struct LDKCResult_CVec_u8ZPeerHandleErrorZ _res);
5105
5106 struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_clone(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR orig);
5107
5108 struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_ok(void);
5109
5110 struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_err(struct LDKPeerHandleError e);
5111
5112 void CResult_NonePeerHandleErrorZ_free(struct LDKCResult_NonePeerHandleErrorZ _res);
5113
5114 struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_clone(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR orig);
5115
5116 struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_ok(bool o);
5117
5118 struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_err(struct LDKPeerHandleError e);
5119
5120 void CResult_boolPeerHandleErrorZ_free(struct LDKCResult_boolPeerHandleErrorZ _res);
5121
5122 struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_clone(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR orig);
5123
5124 struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_ok(struct LDKInitFeatures o);
5125
5126 struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
5127
5128 void CResult_InitFeaturesDecodeErrorZ_free(struct LDKCResult_InitFeaturesDecodeErrorZ _res);
5129
5130 struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_ok(struct LDKNodeFeatures o);
5131
5132 struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
5133
5134 void CResult_NodeFeaturesDecodeErrorZ_free(struct LDKCResult_NodeFeaturesDecodeErrorZ _res);
5135
5136 struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_ok(struct LDKChannelFeatures o);
5137
5138 struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
5139
5140 void CResult_ChannelFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelFeaturesDecodeErrorZ _res);
5141
5142 struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_ok(struct LDKInvoiceFeatures o);
5143
5144 struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
5145
5146 void CResult_InvoiceFeaturesDecodeErrorZ_free(struct LDKCResult_InvoiceFeaturesDecodeErrorZ _res);
5147
5148 struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_ok(struct LDKChannelConfig o);
5149
5150 struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_err(struct LDKDecodeError e);
5151
5152 void CResult_ChannelConfigDecodeErrorZ_free(struct LDKCResult_ChannelConfigDecodeErrorZ _res);
5153
5154 struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_clone(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR orig);
5155
5156 struct LDKCResult_DirectionalChannelInfoDecodeErrorZ CResult_DirectionalChannelInfoDecodeErrorZ_ok(struct LDKDirectionalChannelInfo o);
5157
5158 struct LDKCResult_DirectionalChannelInfoDecodeErrorZ CResult_DirectionalChannelInfoDecodeErrorZ_err(struct LDKDecodeError e);
5159
5160 void CResult_DirectionalChannelInfoDecodeErrorZ_free(struct LDKCResult_DirectionalChannelInfoDecodeErrorZ _res);
5161
5162 struct LDKCResult_DirectionalChannelInfoDecodeErrorZ CResult_DirectionalChannelInfoDecodeErrorZ_clone(const struct LDKCResult_DirectionalChannelInfoDecodeErrorZ *NONNULL_PTR orig);
5163
5164 struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_ok(struct LDKChannelInfo o);
5165
5166 struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_err(struct LDKDecodeError e);
5167
5168 void CResult_ChannelInfoDecodeErrorZ_free(struct LDKCResult_ChannelInfoDecodeErrorZ _res);
5169
5170 struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR orig);
5171
5172 struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_ok(struct LDKRoutingFees o);
5173
5174 struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_err(struct LDKDecodeError e);
5175
5176 void CResult_RoutingFeesDecodeErrorZ_free(struct LDKCResult_RoutingFeesDecodeErrorZ _res);
5177
5178 struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_clone(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR orig);
5179
5180 void CVec_NetAddressZ_free(struct LDKCVec_NetAddressZ _res);
5181
5182 struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_ok(struct LDKNodeAnnouncementInfo o);
5183
5184 struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_err(struct LDKDecodeError e);
5185
5186 void CResult_NodeAnnouncementInfoDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ _res);
5187
5188 struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR orig);
5189
5190 void CVec_u64Z_free(struct LDKCVec_u64Z _res);
5191
5192 struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_ok(struct LDKNodeInfo o);
5193
5194 struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_err(struct LDKDecodeError e);
5195
5196 void CResult_NodeInfoDecodeErrorZ_free(struct LDKCResult_NodeInfoDecodeErrorZ _res);
5197
5198 struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_clone(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR orig);
5199
5200 struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_ok(struct LDKNetworkGraph o);
5201
5202 struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_err(struct LDKDecodeError e);
5203
5204 void CResult_NetworkGraphDecodeErrorZ_free(struct LDKCResult_NetworkGraphDecodeErrorZ _res);
5205
5206 struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_clone(const struct LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR orig);
5207
5208 struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_new(uintptr_t a, struct LDKTransaction b);
5209
5210 void C2Tuple_usizeTransactionZ_free(struct LDKC2Tuple_usizeTransactionZ _res);
5211
5212 void CVec_C2Tuple_usizeTransactionZZ_free(struct LDKCVec_C2Tuple_usizeTransactionZZ _res);
5213
5214 struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_ok(void);
5215
5216 struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_err(enum LDKChannelMonitorUpdateErr e);
5217
5218 void CResult_NoneChannelMonitorUpdateErrZ_free(struct LDKCResult_NoneChannelMonitorUpdateErrZ _res);
5219
5220 struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_clone(const struct LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR orig);
5221
5222 void CVec_MonitorEventZ_free(struct LDKCVec_MonitorEventZ _res);
5223
5224 void CVec_EventZ_free(struct LDKCVec_EventZ _res);
5225
5226 struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_ok(struct LDKOutPoint o);
5227
5228 struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_err(struct LDKDecodeError e);
5229
5230 void CResult_OutPointDecodeErrorZ_free(struct LDKCResult_OutPointDecodeErrorZ _res);
5231
5232 struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_clone(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR orig);
5233
5234 struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_ok(struct LDKChannelMonitorUpdate o);
5235
5236 struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_err(struct LDKDecodeError e);
5237
5238 void CResult_ChannelMonitorUpdateDecodeErrorZ_free(struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ _res);
5239
5240 struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR orig);
5241
5242 struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_ok(struct LDKHTLCUpdate o);
5243
5244 struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_err(struct LDKDecodeError e);
5245
5246 void CResult_HTLCUpdateDecodeErrorZ_free(struct LDKCResult_HTLCUpdateDecodeErrorZ _res);
5247
5248 struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_clone(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR orig);
5249
5250 struct LDKCResult_NoneMonitorUpdateErrorZ CResult_NoneMonitorUpdateErrorZ_ok(void);
5251
5252 struct LDKCResult_NoneMonitorUpdateErrorZ CResult_NoneMonitorUpdateErrorZ_err(struct LDKMonitorUpdateError e);
5253
5254 void CResult_NoneMonitorUpdateErrorZ_free(struct LDKCResult_NoneMonitorUpdateErrorZ _res);
5255
5256 struct LDKCResult_NoneMonitorUpdateErrorZ CResult_NoneMonitorUpdateErrorZ_clone(const struct LDKCResult_NoneMonitorUpdateErrorZ *NONNULL_PTR orig);
5257
5258 struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_clone(const struct LDKC2Tuple_OutPointScriptZ *NONNULL_PTR orig);
5259
5260 struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_new(struct LDKOutPoint a, struct LDKCVec_u8Z b);
5261
5262 void C2Tuple_OutPointScriptZ_free(struct LDKC2Tuple_OutPointScriptZ _res);
5263
5264 struct LDKC2Tuple_u32ScriptZ C2Tuple_u32ScriptZ_clone(const struct LDKC2Tuple_u32ScriptZ *NONNULL_PTR orig);
5265
5266 struct LDKC2Tuple_u32ScriptZ C2Tuple_u32ScriptZ_new(uint32_t a, struct LDKCVec_u8Z b);
5267
5268 void C2Tuple_u32ScriptZ_free(struct LDKC2Tuple_u32ScriptZ _res);
5269
5270 void CVec_C2Tuple_u32ScriptZZ_free(struct LDKCVec_C2Tuple_u32ScriptZZ _res);
5271
5272 struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32ScriptZZ b);
5273
5274 void C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ _res);
5275
5276 void CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ _res);
5277
5278 void CVec_TransactionZ_free(struct LDKCVec_TransactionZ _res);
5279
5280 struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_clone(const struct LDKC2Tuple_u32TxOutZ *NONNULL_PTR orig);
5281
5282 struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_new(uint32_t a, struct LDKTxOut b);
5283
5284 void C2Tuple_u32TxOutZ_free(struct LDKC2Tuple_u32TxOutZ _res);
5285
5286 void CVec_C2Tuple_u32TxOutZZ_free(struct LDKCVec_C2Tuple_u32TxOutZZ _res);
5287
5288 struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32TxOutZZ b);
5289
5290 void C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ _res);
5291
5292 void CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ _res);
5293
5294 struct LDKC2Tuple_BlockHashChannelMonitorZ C2Tuple_BlockHashChannelMonitorZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelMonitor b);
5295
5296 void C2Tuple_BlockHashChannelMonitorZ_free(struct LDKC2Tuple_BlockHashChannelMonitorZ _res);
5297
5298 struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelMonitorZ o);
5299
5300 struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(struct LDKDecodeError e);
5301
5302 void CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ _res);
5303
5304 void CVec_SpendableOutputDescriptorZ_free(struct LDKCVec_SpendableOutputDescriptorZ _res);
5305
5306 struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_ok(struct LDKTxOut o);
5307
5308 struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_err(enum LDKAccessError e);
5309
5310 void CResult_TxOutAccessErrorZ_free(struct LDKCResult_TxOutAccessErrorZ _res);
5311
5312 struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_clone(const struct LDKCResult_TxOutAccessErrorZ *NONNULL_PTR orig);
5313
5314 struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_ok(void);
5315
5316 struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_err(struct LDKAPIError e);
5317
5318 void CResult_NoneAPIErrorZ_free(struct LDKCResult_NoneAPIErrorZ _res);
5319
5320 struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_clone(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR orig);
5321
5322 void CVec_CResult_NoneAPIErrorZZ_free(struct LDKCVec_CResult_NoneAPIErrorZZ _res);
5323
5324 void CVec_APIErrorZ_free(struct LDKCVec_APIErrorZ _res);
5325
5326 void CVec_ChannelDetailsZ_free(struct LDKCVec_ChannelDetailsZ _res);
5327
5328 struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_ok(void);
5329
5330 struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
5331
5332 void CResult_NonePaymentSendFailureZ_free(struct LDKCResult_NonePaymentSendFailureZ _res);
5333
5334 struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_clone(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR orig);
5335
5336 void CVec_ChannelMonitorZ_free(struct LDKCVec_ChannelMonitorZ _res);
5337
5338 struct LDKC2Tuple_BlockHashChannelManagerZ C2Tuple_BlockHashChannelManagerZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelManager b);
5339
5340 void C2Tuple_BlockHashChannelManagerZ_free(struct LDKC2Tuple_BlockHashChannelManagerZ _res);
5341
5342 struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelManagerZ o);
5343
5344 struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(struct LDKDecodeError e);
5345
5346 void CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ _res);
5347
5348 struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_ok(struct LDKSpendableOutputDescriptor o);
5349
5350 struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
5351
5352 void CResult_SpendableOutputDescriptorDecodeErrorZ_free(struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ _res);
5353
5354 struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
5355
5356 struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_clone(const struct LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR orig);
5357
5358 struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_new(struct LDKSignature a, struct LDKCVec_SignatureZ b);
5359
5360 void C2Tuple_SignatureCVec_SignatureZZ_free(struct LDKC2Tuple_SignatureCVec_SignatureZZ _res);
5361
5362 struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(struct LDKC2Tuple_SignatureCVec_SignatureZZ o);
5363
5364 struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(void);
5365
5366 void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ _res);
5367
5368 struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(const struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR orig);
5369
5370 struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_ok(struct LDKSignature o);
5371
5372 struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_err(void);
5373
5374 void CResult_SignatureNoneZ_free(struct LDKCResult_SignatureNoneZ _res);
5375
5376 struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_clone(const struct LDKCResult_SignatureNoneZ *NONNULL_PTR orig);
5377
5378 struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_ok(struct LDKSign o);
5379
5380 struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_err(struct LDKDecodeError e);
5381
5382 void CResult_SignDecodeErrorZ_free(struct LDKCResult_SignDecodeErrorZ _res);
5383
5384 struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_clone(const struct LDKCResult_SignDecodeErrorZ *NONNULL_PTR orig);
5385
5386 void CVec_CVec_u8ZZ_free(struct LDKCVec_CVec_u8ZZ _res);
5387
5388 struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_ok(struct LDKCVec_CVec_u8ZZ o);
5389
5390 struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_err(void);
5391
5392 void CResult_CVec_CVec_u8ZZNoneZ_free(struct LDKCResult_CVec_CVec_u8ZZNoneZ _res);
5393
5394 struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_clone(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR orig);
5395
5396 struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_ok(struct LDKInMemorySigner o);
5397
5398 struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_err(struct LDKDecodeError e);
5399
5400 void CResult_InMemorySignerDecodeErrorZ_free(struct LDKCResult_InMemorySignerDecodeErrorZ _res);
5401
5402 struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_clone(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR orig);
5403
5404 void CVec_TxOutZ_free(struct LDKCVec_TxOutZ _res);
5405
5406 struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_ok(struct LDKTransaction o);
5407
5408 struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_err(void);
5409
5410 void CResult_TransactionNoneZ_free(struct LDKCResult_TransactionNoneZ _res);
5411
5412 void CVec_RouteHopZ_free(struct LDKCVec_RouteHopZ _res);
5413
5414 void CVec_CVec_RouteHopZZ_free(struct LDKCVec_CVec_RouteHopZZ _res);
5415
5416 struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_ok(struct LDKRoute o);
5417
5418 struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_err(struct LDKDecodeError e);
5419
5420 void CResult_RouteDecodeErrorZ_free(struct LDKCResult_RouteDecodeErrorZ _res);
5421
5422 struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_clone(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR orig);
5423
5424 void CVec_RouteHintZ_free(struct LDKCVec_RouteHintZ _res);
5425
5426 struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_ok(struct LDKRoute o);
5427
5428 struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_err(struct LDKLightningError e);
5429
5430 void CResult_RouteLightningErrorZ_free(struct LDKCResult_RouteLightningErrorZ _res);
5431
5432 struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_clone(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR orig);
5433
5434 struct LDKCResult_NetAddressu8Z CResult_NetAddressu8Z_ok(struct LDKNetAddress o);
5435
5436 struct LDKCResult_NetAddressu8Z CResult_NetAddressu8Z_err(uint8_t e);
5437
5438 void CResult_NetAddressu8Z_free(struct LDKCResult_NetAddressu8Z _res);
5439
5440 struct LDKCResult_NetAddressu8Z CResult_NetAddressu8Z_clone(const struct LDKCResult_NetAddressu8Z *NONNULL_PTR orig);
5441
5442 struct LDKCResult_CResult_NetAddressu8ZDecodeErrorZ CResult_CResult_NetAddressu8ZDecodeErrorZ_ok(struct LDKCResult_NetAddressu8Z o);
5443
5444 struct LDKCResult_CResult_NetAddressu8ZDecodeErrorZ CResult_CResult_NetAddressu8ZDecodeErrorZ_err(struct LDKDecodeError e);
5445
5446 void CResult_CResult_NetAddressu8ZDecodeErrorZ_free(struct LDKCResult_CResult_NetAddressu8ZDecodeErrorZ _res);
5447
5448 struct LDKCResult_CResult_NetAddressu8ZDecodeErrorZ CResult_CResult_NetAddressu8ZDecodeErrorZ_clone(const struct LDKCResult_CResult_NetAddressu8ZDecodeErrorZ *NONNULL_PTR orig);
5449
5450 void CVec_UpdateAddHTLCZ_free(struct LDKCVec_UpdateAddHTLCZ _res);
5451
5452 void CVec_UpdateFulfillHTLCZ_free(struct LDKCVec_UpdateFulfillHTLCZ _res);
5453
5454 void CVec_UpdateFailHTLCZ_free(struct LDKCVec_UpdateFailHTLCZ _res);
5455
5456 void CVec_UpdateFailMalformedHTLCZ_free(struct LDKCVec_UpdateFailMalformedHTLCZ _res);
5457
5458 struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_ok(struct LDKAcceptChannel o);
5459
5460 struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_err(struct LDKDecodeError e);
5461
5462 void CResult_AcceptChannelDecodeErrorZ_free(struct LDKCResult_AcceptChannelDecodeErrorZ _res);
5463
5464 struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_clone(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR orig);
5465
5466 struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_ok(struct LDKAnnouncementSignatures o);
5467
5468 struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_err(struct LDKDecodeError e);
5469
5470 void CResult_AnnouncementSignaturesDecodeErrorZ_free(struct LDKCResult_AnnouncementSignaturesDecodeErrorZ _res);
5471
5472 struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_clone(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR orig);
5473
5474 struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_ok(struct LDKChannelReestablish o);
5475
5476 struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_err(struct LDKDecodeError e);
5477
5478 void CResult_ChannelReestablishDecodeErrorZ_free(struct LDKCResult_ChannelReestablishDecodeErrorZ _res);
5479
5480 struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_clone(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR orig);
5481
5482 struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_ok(struct LDKClosingSigned o);
5483
5484 struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_err(struct LDKDecodeError e);
5485
5486 void CResult_ClosingSignedDecodeErrorZ_free(struct LDKCResult_ClosingSignedDecodeErrorZ _res);
5487
5488 struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR orig);
5489
5490 struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_ok(struct LDKCommitmentSigned o);
5491
5492 struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_err(struct LDKDecodeError e);
5493
5494 void CResult_CommitmentSignedDecodeErrorZ_free(struct LDKCResult_CommitmentSignedDecodeErrorZ _res);
5495
5496 struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_clone(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR orig);
5497
5498 struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_ok(struct LDKFundingCreated o);
5499
5500 struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_err(struct LDKDecodeError e);
5501
5502 void CResult_FundingCreatedDecodeErrorZ_free(struct LDKCResult_FundingCreatedDecodeErrorZ _res);
5503
5504 struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_clone(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR orig);
5505
5506 struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_ok(struct LDKFundingSigned o);
5507
5508 struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_err(struct LDKDecodeError e);
5509
5510 void CResult_FundingSignedDecodeErrorZ_free(struct LDKCResult_FundingSignedDecodeErrorZ _res);
5511
5512 struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_clone(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR orig);
5513
5514 struct LDKCResult_FundingLockedDecodeErrorZ CResult_FundingLockedDecodeErrorZ_ok(struct LDKFundingLocked o);
5515
5516 struct LDKCResult_FundingLockedDecodeErrorZ CResult_FundingLockedDecodeErrorZ_err(struct LDKDecodeError e);
5517
5518 void CResult_FundingLockedDecodeErrorZ_free(struct LDKCResult_FundingLockedDecodeErrorZ _res);
5519
5520 struct LDKCResult_FundingLockedDecodeErrorZ CResult_FundingLockedDecodeErrorZ_clone(const struct LDKCResult_FundingLockedDecodeErrorZ *NONNULL_PTR orig);
5521
5522 struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_ok(struct LDKInit o);
5523
5524 struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_err(struct LDKDecodeError e);
5525
5526 void CResult_InitDecodeErrorZ_free(struct LDKCResult_InitDecodeErrorZ _res);
5527
5528 struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_clone(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR orig);
5529
5530 struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_ok(struct LDKOpenChannel o);
5531
5532 struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_err(struct LDKDecodeError e);
5533
5534 void CResult_OpenChannelDecodeErrorZ_free(struct LDKCResult_OpenChannelDecodeErrorZ _res);
5535
5536 struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_clone(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR orig);
5537
5538 struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_ok(struct LDKRevokeAndACK o);
5539
5540 struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_err(struct LDKDecodeError e);
5541
5542 void CResult_RevokeAndACKDecodeErrorZ_free(struct LDKCResult_RevokeAndACKDecodeErrorZ _res);
5543
5544 struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_clone(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR orig);
5545
5546 struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_ok(struct LDKShutdown o);
5547
5548 struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_err(struct LDKDecodeError e);
5549
5550 void CResult_ShutdownDecodeErrorZ_free(struct LDKCResult_ShutdownDecodeErrorZ _res);
5551
5552 struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_clone(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR orig);
5553
5554 struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_ok(struct LDKUpdateFailHTLC o);
5555
5556 struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_err(struct LDKDecodeError e);
5557
5558 void CResult_UpdateFailHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailHTLCDecodeErrorZ _res);
5559
5560 struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR orig);
5561
5562 struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(struct LDKUpdateFailMalformedHTLC o);
5563
5564 struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(struct LDKDecodeError e);
5565
5566 void CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ _res);
5567
5568 struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR orig);
5569
5570 struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_ok(struct LDKUpdateFee o);
5571
5572 struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_err(struct LDKDecodeError e);
5573
5574 void CResult_UpdateFeeDecodeErrorZ_free(struct LDKCResult_UpdateFeeDecodeErrorZ _res);
5575
5576 struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_clone(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR orig);
5577
5578 struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_ok(struct LDKUpdateFulfillHTLC o);
5579
5580 struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_err(struct LDKDecodeError e);
5581
5582 void CResult_UpdateFulfillHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ _res);
5583
5584 struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR orig);
5585
5586 struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_ok(struct LDKUpdateAddHTLC o);
5587
5588 struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_err(struct LDKDecodeError e);
5589
5590 void CResult_UpdateAddHTLCDecodeErrorZ_free(struct LDKCResult_UpdateAddHTLCDecodeErrorZ _res);
5591
5592 struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR orig);
5593
5594 struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_ok(struct LDKPing o);
5595
5596 struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_err(struct LDKDecodeError e);
5597
5598 void CResult_PingDecodeErrorZ_free(struct LDKCResult_PingDecodeErrorZ _res);
5599
5600 struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_clone(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR orig);
5601
5602 struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_ok(struct LDKPong o);
5603
5604 struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_err(struct LDKDecodeError e);
5605
5606 void CResult_PongDecodeErrorZ_free(struct LDKCResult_PongDecodeErrorZ _res);
5607
5608 struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_clone(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR orig);
5609
5610 struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(struct LDKUnsignedChannelAnnouncement o);
5611
5612 struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
5613
5614 void CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ _res);
5615
5616 struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
5617
5618 struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_ok(struct LDKChannelAnnouncement o);
5619
5620 struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
5621
5622 void CResult_ChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_ChannelAnnouncementDecodeErrorZ _res);
5623
5624 struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
5625
5626 struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_ok(struct LDKUnsignedChannelUpdate o);
5627
5628 struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
5629
5630 void CResult_UnsignedChannelUpdateDecodeErrorZ_free(struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ _res);
5631
5632 struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
5633
5634 struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_ok(struct LDKChannelUpdate o);
5635
5636 struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
5637
5638 void CResult_ChannelUpdateDecodeErrorZ_free(struct LDKCResult_ChannelUpdateDecodeErrorZ _res);
5639
5640 struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
5641
5642 struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_ok(struct LDKErrorMessage o);
5643
5644 struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_err(struct LDKDecodeError e);
5645
5646 void CResult_ErrorMessageDecodeErrorZ_free(struct LDKCResult_ErrorMessageDecodeErrorZ _res);
5647
5648 struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_clone(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR orig);
5649
5650 struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(struct LDKUnsignedNodeAnnouncement o);
5651
5652 struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
5653
5654 void CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ _res);
5655
5656 struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
5657
5658 struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_ok(struct LDKNodeAnnouncement o);
5659
5660 struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
5661
5662 void CResult_NodeAnnouncementDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementDecodeErrorZ _res);
5663
5664 struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
5665
5666 struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_ok(struct LDKQueryShortChannelIds o);
5667
5668 struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_err(struct LDKDecodeError e);
5669
5670 void CResult_QueryShortChannelIdsDecodeErrorZ_free(struct LDKCResult_QueryShortChannelIdsDecodeErrorZ _res);
5671
5672 struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_clone(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR orig);
5673
5674 struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(struct LDKReplyShortChannelIdsEnd o);
5675
5676 struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(struct LDKDecodeError e);
5677
5678 void CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ _res);
5679
5680 struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR orig);
5681
5682 struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_ok(struct LDKQueryChannelRange o);
5683
5684 struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
5685
5686 void CResult_QueryChannelRangeDecodeErrorZ_free(struct LDKCResult_QueryChannelRangeDecodeErrorZ _res);
5687
5688 struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_clone(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR orig);
5689
5690 struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_ok(struct LDKReplyChannelRange o);
5691
5692 struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
5693
5694 void CResult_ReplyChannelRangeDecodeErrorZ_free(struct LDKCResult_ReplyChannelRangeDecodeErrorZ _res);
5695
5696 struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_clone(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR orig);
5697
5698 struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_ok(struct LDKGossipTimestampFilter o);
5699
5700 struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_err(struct LDKDecodeError e);
5701
5702 void CResult_GossipTimestampFilterDecodeErrorZ_free(struct LDKCResult_GossipTimestampFilterDecodeErrorZ _res);
5703
5704 struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_clone(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR orig);
5705
5706 /**
5707  * Frees any resources used by the Event
5708  */
5709 void Event_free(struct LDKEvent this_ptr);
5710
5711 /**
5712  * Creates a copy of the Event
5713  */
5714 struct LDKEvent Event_clone(const struct LDKEvent *NONNULL_PTR orig);
5715
5716 /**
5717  * Serialize the Event object into a byte array which can be read by Event_read
5718  */
5719 struct LDKCVec_u8Z Event_write(const struct LDKEvent *NONNULL_PTR obj);
5720
5721 /**
5722  * Frees any resources used by the MessageSendEvent
5723  */
5724 void MessageSendEvent_free(struct LDKMessageSendEvent this_ptr);
5725
5726 /**
5727  * Creates a copy of the MessageSendEvent
5728  */
5729 struct LDKMessageSendEvent MessageSendEvent_clone(const struct LDKMessageSendEvent *NONNULL_PTR orig);
5730
5731 /**
5732  * Calls the free function if one is set
5733  */
5734 void MessageSendEventsProvider_free(struct LDKMessageSendEventsProvider this_ptr);
5735
5736 /**
5737  * Calls the free function if one is set
5738  */
5739 void EventsProvider_free(struct LDKEventsProvider this_ptr);
5740
5741 /**
5742  * Frees any resources used by the APIError
5743  */
5744 void APIError_free(struct LDKAPIError this_ptr);
5745
5746 /**
5747  * Creates a copy of the APIError
5748  */
5749 struct LDKAPIError APIError_clone(const struct LDKAPIError *NONNULL_PTR orig);
5750
5751 /**
5752  * Creates a copy of the Level
5753  */
5754 enum LDKLevel Level_clone(const enum LDKLevel *NONNULL_PTR orig);
5755
5756 /**
5757  * Returns the most verbose logging level.
5758  */
5759 MUST_USE_RES enum LDKLevel Level_max(void);
5760
5761 /**
5762  * Calls the free function if one is set
5763  */
5764 void Logger_free(struct LDKLogger this_ptr);
5765
5766 /**
5767  * Frees any resources used by the ChannelHandshakeConfig, if is_owned is set and inner is non-NULL.
5768  */
5769 void ChannelHandshakeConfig_free(struct LDKChannelHandshakeConfig this_obj);
5770
5771 /**
5772  * Confirmations we will wait for before considering the channel locked in.
5773  * Applied only for inbound channels (see ChannelHandshakeLimits::max_minimum_depth for the
5774  * equivalent limit applied to outbound channels).
5775  *
5776  * Default value: 6.
5777  */
5778 uint32_t ChannelHandshakeConfig_get_minimum_depth(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
5779
5780 /**
5781  * Confirmations we will wait for before considering the channel locked in.
5782  * Applied only for inbound channels (see ChannelHandshakeLimits::max_minimum_depth for the
5783  * equivalent limit applied to outbound channels).
5784  *
5785  * Default value: 6.
5786  */
5787 void ChannelHandshakeConfig_set_minimum_depth(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint32_t val);
5788
5789 /**
5790  * Set to the amount of time we require our counterparty to wait to claim their money.
5791  *
5792  * It's one of the main parameter of our security model. We (or one of our watchtowers) MUST
5793  * be online to check for peer having broadcast a revoked transaction to steal our funds
5794  * at least once every our_to_self_delay blocks.
5795  *
5796  * Meanwhile, asking for a too high delay, we bother peer to freeze funds for nothing in
5797  * case of an honest unilateral channel close, which implicitly decrease the economic value of
5798  * our channel.
5799  *
5800  * Default value: [`BREAKDOWN_TIMEOUT`] (currently 144), we enforce it as a minimum at channel
5801  * opening so you can tweak config to ask for more security, not less.
5802  */
5803 uint16_t ChannelHandshakeConfig_get_our_to_self_delay(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
5804
5805 /**
5806  * Set to the amount of time we require our counterparty to wait to claim their money.
5807  *
5808  * It's one of the main parameter of our security model. We (or one of our watchtowers) MUST
5809  * be online to check for peer having broadcast a revoked transaction to steal our funds
5810  * at least once every our_to_self_delay blocks.
5811  *
5812  * Meanwhile, asking for a too high delay, we bother peer to freeze funds for nothing in
5813  * case of an honest unilateral channel close, which implicitly decrease the economic value of
5814  * our channel.
5815  *
5816  * Default value: [`BREAKDOWN_TIMEOUT`] (currently 144), we enforce it as a minimum at channel
5817  * opening so you can tweak config to ask for more security, not less.
5818  */
5819 void ChannelHandshakeConfig_set_our_to_self_delay(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint16_t val);
5820
5821 /**
5822  * Set to the smallest value HTLC we will accept to process.
5823  *
5824  * This value is sent to our counterparty on channel-open and we close the channel any time
5825  * our counterparty misbehaves by sending us an HTLC with a value smaller than this.
5826  *
5827  * Default value: 1. If the value is less than 1, it is ignored and set to 1, as is required
5828  * by the protocol.
5829  */
5830 uint64_t ChannelHandshakeConfig_get_our_htlc_minimum_msat(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
5831
5832 /**
5833  * Set to the smallest value HTLC we will accept to process.
5834  *
5835  * This value is sent to our counterparty on channel-open and we close the channel any time
5836  * our counterparty misbehaves by sending us an HTLC with a value smaller than this.
5837  *
5838  * Default value: 1. If the value is less than 1, it is ignored and set to 1, as is required
5839  * by the protocol.
5840  */
5841 void ChannelHandshakeConfig_set_our_htlc_minimum_msat(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint64_t val);
5842
5843 /**
5844  * Constructs a new ChannelHandshakeConfig given each field
5845  */
5846 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);
5847
5848 /**
5849  * Creates a copy of the ChannelHandshakeConfig
5850  */
5851 struct LDKChannelHandshakeConfig ChannelHandshakeConfig_clone(const struct LDKChannelHandshakeConfig *NONNULL_PTR orig);
5852
5853 /**
5854  * Creates a "default" ChannelHandshakeConfig. See struct and individual field documentaiton for details on which values are used.
5855  */
5856 MUST_USE_RES struct LDKChannelHandshakeConfig ChannelHandshakeConfig_default(void);
5857
5858 /**
5859  * Frees any resources used by the ChannelHandshakeLimits, if is_owned is set and inner is non-NULL.
5860  */
5861 void ChannelHandshakeLimits_free(struct LDKChannelHandshakeLimits this_obj);
5862
5863 /**
5864  * Minimum allowed satoshis when a channel is funded, this is supplied by the sender and so
5865  * only applies to inbound channels.
5866  *
5867  * Default value: 0.
5868  */
5869 uint64_t ChannelHandshakeLimits_get_min_funding_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
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 void ChannelHandshakeLimits_set_min_funding_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
5878
5879 /**
5880  * The remote node sets a limit on the minimum size of HTLCs we can send to them. This allows
5881  * you to limit the maximum minimum-size they can require.
5882  *
5883  * Default value: u64::max_value.
5884  */
5885 uint64_t ChannelHandshakeLimits_get_max_htlc_minimum_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
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 void ChannelHandshakeLimits_set_max_htlc_minimum_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
5894
5895 /**
5896  * The remote node sets a limit on the maximum value of pending HTLCs to them at any given
5897  * time to limit their funds exposure to HTLCs. This allows you to set a minimum such value.
5898  *
5899  * Default value: 0.
5900  */
5901 uint64_t ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
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 void ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
5910
5911 /**
5912  * The remote node will require we keep a certain amount in direct payment to ourselves at all
5913  * time, ensuring that we are able to be punished if we broadcast an old state. This allows to
5914  * you limit the amount which we will have to keep to ourselves (and cannot use for HTLCs).
5915  *
5916  * Default value: u64::max_value.
5917  */
5918 uint64_t ChannelHandshakeLimits_get_max_channel_reserve_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
5919
5920 /**
5921  * The remote node will require we keep a certain amount in direct payment to ourselves at all
5922  * time, ensuring that we are able to be punished if we broadcast an old state. This allows to
5923  * you limit the amount which we will have to keep to ourselves (and cannot use for HTLCs).
5924  *
5925  * Default value: u64::max_value.
5926  */
5927 void ChannelHandshakeLimits_set_max_channel_reserve_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
5928
5929 /**
5930  * The remote node sets a limit on the maximum number of pending HTLCs to them at any given
5931  * time. This allows you to set a minimum such value.
5932  *
5933  * Default value: 0.
5934  */
5935 uint16_t ChannelHandshakeLimits_get_min_max_accepted_htlcs(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
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 void ChannelHandshakeLimits_set_min_max_accepted_htlcs(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
5944
5945 /**
5946  * Outputs below a certain value will not be added to on-chain transactions. The dust value is
5947  * required to always be higher than this value so this only applies to HTLC outputs (and
5948  * potentially to-self outputs before any payments have been made).
5949  * Thus, HTLCs below this amount plus HTLC transaction fees are not enforceable on-chain.
5950  * This setting allows you to set a minimum dust limit for their commitment transactions,
5951  * reflecting the reality that tiny outputs are not considered standard transactions and will
5952  * not propagate through the Bitcoin network.
5953  *
5954  * Default value: 546, the current dust limit on the Bitcoin network.
5955  */
5956 uint64_t ChannelHandshakeLimits_get_min_dust_limit_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
5957
5958 /**
5959  * Outputs below a certain value will not be added to on-chain transactions. The dust value is
5960  * required to always be higher than this value so this only applies to HTLC outputs (and
5961  * potentially to-self outputs before any payments have been made).
5962  * Thus, HTLCs below this amount plus HTLC transaction fees are not enforceable on-chain.
5963  * This setting allows you to set a minimum dust limit for their commitment transactions,
5964  * reflecting the reality that tiny outputs are not considered standard transactions and will
5965  * not propagate through the Bitcoin network.
5966  *
5967  * Default value: 546, the current dust limit on the Bitcoin network.
5968  */
5969 void ChannelHandshakeLimits_set_min_dust_limit_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
5970
5971 /**
5972  * Maximum allowed threshold above which outputs will not be generated in their commitment
5973  * transactions.
5974  * HTLCs below this amount plus HTLC transaction fees are not enforceable on-chain.
5975  *
5976  * Default value: u64::max_value.
5977  */
5978 uint64_t ChannelHandshakeLimits_get_max_dust_limit_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
5979
5980 /**
5981  * Maximum allowed threshold above which outputs will not be generated in their commitment
5982  * transactions.
5983  * HTLCs below this amount plus HTLC transaction fees are not enforceable on-chain.
5984  *
5985  * Default value: u64::max_value.
5986  */
5987 void ChannelHandshakeLimits_set_max_dust_limit_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
5988
5989 /**
5990  * Before a channel is usable the funding transaction will need to be confirmed by at least a
5991  * certain number of blocks, specified by the node which is not the funder (as the funder can
5992  * assume they aren't going to double-spend themselves).
5993  * This config allows you to set a limit on the maximum amount of time to wait.
5994  *
5995  * Default value: 144, or roughly one day and only applies to outbound channels.
5996  */
5997 uint32_t ChannelHandshakeLimits_get_max_minimum_depth(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
5998
5999 /**
6000  * Before a channel is usable the funding transaction will need to be confirmed by at least a
6001  * certain number of blocks, specified by the node which is not the funder (as the funder can
6002  * assume they aren't going to double-spend themselves).
6003  * This config allows you to set a limit on the maximum amount of time to wait.
6004  *
6005  * Default value: 144, or roughly one day and only applies to outbound channels.
6006  */
6007 void ChannelHandshakeLimits_set_max_minimum_depth(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint32_t val);
6008
6009 /**
6010  * Set to force the incoming channel to match our announced channel preference in
6011  * ChannelConfig.
6012  *
6013  * Default value: true, to make the default that no announced channels are possible (which is
6014  * appropriate for any nodes which are not online very reliably).
6015  */
6016 bool ChannelHandshakeLimits_get_force_announced_channel_preference(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
6017
6018 /**
6019  * Set to force the incoming channel to match our announced channel preference in
6020  * ChannelConfig.
6021  *
6022  * Default value: true, to make the default that no announced channels are possible (which is
6023  * appropriate for any nodes which are not online very reliably).
6024  */
6025 void ChannelHandshakeLimits_set_force_announced_channel_preference(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, bool val);
6026
6027 /**
6028  * Set to the amount of time we're willing to wait to claim money back to us.
6029  *
6030  * Not checking this value would be a security issue, as our peer would be able to set it to
6031  * max relative lock-time (a year) and we would \"lose\" money as it would be locked for a long time.
6032  *
6033  * Default value: 2016, which we also enforce as a maximum value so you can tweak config to
6034  * reduce the loss of having useless locked funds (if your peer accepts)
6035  */
6036 uint16_t ChannelHandshakeLimits_get_their_to_self_delay(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
6037
6038 /**
6039  * Set to the amount of time we're willing to wait to claim money back to us.
6040  *
6041  * Not checking this value would be a security issue, as our peer would be able to set it to
6042  * max relative lock-time (a year) and we would \"lose\" money as it would be locked for a long time.
6043  *
6044  * Default value: 2016, which we also enforce as a maximum value so you can tweak config to
6045  * reduce the loss of having useless locked funds (if your peer accepts)
6046  */
6047 void ChannelHandshakeLimits_set_their_to_self_delay(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
6048
6049 /**
6050  * Constructs a new ChannelHandshakeLimits given each field
6051  */
6052 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);
6053
6054 /**
6055  * Creates a copy of the ChannelHandshakeLimits
6056  */
6057 struct LDKChannelHandshakeLimits ChannelHandshakeLimits_clone(const struct LDKChannelHandshakeLimits *NONNULL_PTR orig);
6058
6059 /**
6060  * Creates a "default" ChannelHandshakeLimits. See struct and individual field documentaiton for details on which values are used.
6061  */
6062 MUST_USE_RES struct LDKChannelHandshakeLimits ChannelHandshakeLimits_default(void);
6063
6064 /**
6065  * Frees any resources used by the ChannelConfig, if is_owned is set and inner is non-NULL.
6066  */
6067 void ChannelConfig_free(struct LDKChannelConfig this_obj);
6068
6069 /**
6070  * Amount (in millionths of a satoshi) the channel will charge per transferred satoshi.
6071  * This may be allowed to change at runtime in a later update, however doing so must result in
6072  * update messages sent to notify all nodes of our updated relay fee.
6073  *
6074  * Default value: 0.
6075  */
6076 uint32_t ChannelConfig_get_fee_proportional_millionths(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
6077
6078 /**
6079  * Amount (in millionths of a satoshi) the channel will charge per transferred satoshi.
6080  * This may be allowed to change at runtime in a later update, however doing so must result in
6081  * update messages sent to notify all nodes of our updated relay fee.
6082  *
6083  * Default value: 0.
6084  */
6085 void ChannelConfig_set_fee_proportional_millionths(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
6086
6087 /**
6088  * Set to announce the channel publicly and notify all nodes that they can route via this
6089  * channel.
6090  *
6091  * This should only be set to true for nodes which expect to be online reliably.
6092  *
6093  * As the node which funds a channel picks this value this will only apply for new outbound
6094  * channels unless ChannelHandshakeLimits::force_announced_channel_preferences is set.
6095  *
6096  * This cannot be changed after the initial channel handshake.
6097  *
6098  * Default value: false.
6099  */
6100 bool ChannelConfig_get_announced_channel(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
6101
6102 /**
6103  * Set to announce the channel publicly and notify all nodes that they can route via this
6104  * channel.
6105  *
6106  * This should only be set to true for nodes which expect to be online reliably.
6107  *
6108  * As the node which funds a channel picks this value this will only apply for new outbound
6109  * channels unless ChannelHandshakeLimits::force_announced_channel_preferences is set.
6110  *
6111  * This cannot be changed after the initial channel handshake.
6112  *
6113  * Default value: false.
6114  */
6115 void ChannelConfig_set_announced_channel(struct LDKChannelConfig *NONNULL_PTR this_ptr, bool val);
6116
6117 /**
6118  * When set, we commit to an upfront shutdown_pubkey at channel open. If our counterparty
6119  * supports it, they will then enforce the mutual-close output to us matches what we provided
6120  * at intialization, preventing us from closing to an alternate pubkey.
6121  *
6122  * This is set to true by default to provide a slight increase in security, though ultimately
6123  * any attacker who is able to take control of a channel can just as easily send the funds via
6124  * lightning payments, so we never require that our counterparties support this option.
6125  *
6126  * This cannot be changed after a channel has been initialized.
6127  *
6128  * Default value: true.
6129  */
6130 bool ChannelConfig_get_commit_upfront_shutdown_pubkey(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
6131
6132 /**
6133  * When set, we commit to an upfront shutdown_pubkey at channel open. If our counterparty
6134  * supports it, they will then enforce the mutual-close output to us matches what we provided
6135  * at intialization, preventing us from closing to an alternate pubkey.
6136  *
6137  * This is set to true by default to provide a slight increase in security, though ultimately
6138  * any attacker who is able to take control of a channel can just as easily send the funds via
6139  * lightning payments, so we never require that our counterparties support this option.
6140  *
6141  * This cannot be changed after a channel has been initialized.
6142  *
6143  * Default value: true.
6144  */
6145 void ChannelConfig_set_commit_upfront_shutdown_pubkey(struct LDKChannelConfig *NONNULL_PTR this_ptr, bool val);
6146
6147 /**
6148  * Constructs a new ChannelConfig given each field
6149  */
6150 MUST_USE_RES struct LDKChannelConfig ChannelConfig_new(uint32_t fee_proportional_millionths_arg, bool announced_channel_arg, bool commit_upfront_shutdown_pubkey_arg);
6151
6152 /**
6153  * Creates a copy of the ChannelConfig
6154  */
6155 struct LDKChannelConfig ChannelConfig_clone(const struct LDKChannelConfig *NONNULL_PTR orig);
6156
6157 /**
6158  * Creates a "default" ChannelConfig. See struct and individual field documentaiton for details on which values are used.
6159  */
6160 MUST_USE_RES struct LDKChannelConfig ChannelConfig_default(void);
6161
6162 /**
6163  * Serialize the ChannelConfig object into a byte array which can be read by ChannelConfig_read
6164  */
6165 struct LDKCVec_u8Z ChannelConfig_write(const struct LDKChannelConfig *NONNULL_PTR obj);
6166
6167 /**
6168  * Read a ChannelConfig from a byte array, created by ChannelConfig_write
6169  */
6170 struct LDKCResult_ChannelConfigDecodeErrorZ ChannelConfig_read(struct LDKu8slice ser);
6171
6172 /**
6173  * Frees any resources used by the UserConfig, if is_owned is set and inner is non-NULL.
6174  */
6175 void UserConfig_free(struct LDKUserConfig this_obj);
6176
6177 /**
6178  * Channel config that we propose to our counterparty.
6179  */
6180 struct LDKChannelHandshakeConfig UserConfig_get_own_channel_config(const struct LDKUserConfig *NONNULL_PTR this_ptr);
6181
6182 /**
6183  * Channel config that we propose to our counterparty.
6184  */
6185 void UserConfig_set_own_channel_config(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeConfig val);
6186
6187 /**
6188  * Limits applied to our counterparty's proposed channel config settings.
6189  */
6190 struct LDKChannelHandshakeLimits UserConfig_get_peer_channel_config_limits(const struct LDKUserConfig *NONNULL_PTR this_ptr);
6191
6192 /**
6193  * Limits applied to our counterparty's proposed channel config settings.
6194  */
6195 void UserConfig_set_peer_channel_config_limits(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeLimits val);
6196
6197 /**
6198  * Channel config which affects behavior during channel lifetime.
6199  */
6200 struct LDKChannelConfig UserConfig_get_channel_options(const struct LDKUserConfig *NONNULL_PTR this_ptr);
6201
6202 /**
6203  * Channel config which affects behavior during channel lifetime.
6204  */
6205 void UserConfig_set_channel_options(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelConfig val);
6206
6207 /**
6208  * Constructs a new UserConfig given each field
6209  */
6210 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);
6211
6212 /**
6213  * Creates a copy of the UserConfig
6214  */
6215 struct LDKUserConfig UserConfig_clone(const struct LDKUserConfig *NONNULL_PTR orig);
6216
6217 /**
6218  * Creates a "default" UserConfig. See struct and individual field documentaiton for details on which values are used.
6219  */
6220 MUST_USE_RES struct LDKUserConfig UserConfig_default(void);
6221
6222 /**
6223  * Creates a copy of the AccessError
6224  */
6225 enum LDKAccessError AccessError_clone(const enum LDKAccessError *NONNULL_PTR orig);
6226
6227 /**
6228  * Calls the free function if one is set
6229  */
6230 void Access_free(struct LDKAccess this_ptr);
6231
6232 /**
6233  * Calls the free function if one is set
6234  */
6235 void Listen_free(struct LDKListen this_ptr);
6236
6237 /**
6238  * Calls the free function if one is set
6239  */
6240 void Watch_free(struct LDKWatch this_ptr);
6241
6242 /**
6243  * Calls the free function if one is set
6244  */
6245 void Filter_free(struct LDKFilter this_ptr);
6246
6247 /**
6248  * Calls the free function if one is set
6249  */
6250 void BroadcasterInterface_free(struct LDKBroadcasterInterface this_ptr);
6251
6252 /**
6253  * Creates a copy of the ConfirmationTarget
6254  */
6255 enum LDKConfirmationTarget ConfirmationTarget_clone(const enum LDKConfirmationTarget *NONNULL_PTR orig);
6256
6257 /**
6258  * Calls the free function if one is set
6259  */
6260 void FeeEstimator_free(struct LDKFeeEstimator this_ptr);
6261
6262 /**
6263  * Frees any resources used by the ChainMonitor, if is_owned is set and inner is non-NULL.
6264  */
6265 void ChainMonitor_free(struct LDKChainMonitor this_obj);
6266
6267 /**
6268  * Dispatches to per-channel monitors, which are responsible for updating their on-chain view
6269  * of a channel and reacting accordingly based on transactions in the connected block. See
6270  * [`ChannelMonitor::block_connected`] for details. Any HTLCs that were resolved on chain will
6271  * be returned by [`chain::Watch::release_pending_monitor_events`].
6272  *
6273  * Calls back to [`chain::Filter`] if any monitor indicated new outputs to watch. Subsequent
6274  * calls must not exclude any transactions matching the new outputs nor any in-block
6275  * descendants of such transactions. It is not necessary to re-fetch the block to obtain
6276  * updated `txdata`.
6277  */
6278 void ChainMonitor_block_connected(const struct LDKChainMonitor *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height);
6279
6280 /**
6281  * Dispatches to per-channel monitors, which are responsible for updating their on-chain view
6282  * of a channel based on the disconnected block. See [`ChannelMonitor::block_disconnected`] for
6283  * details.
6284  */
6285 void ChainMonitor_block_disconnected(const struct LDKChainMonitor *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t disconnected_height);
6286
6287 /**
6288  * Creates a new `ChainMonitor` used to watch on-chain activity pertaining to channels.
6289  *
6290  * When an optional chain source implementing [`chain::Filter`] is provided, the chain monitor
6291  * will call back to it indicating transactions and outputs of interest. This allows clients to
6292  * pre-filter blocks or only fetch blocks matching a compact filter. Otherwise, clients may
6293  * always need to fetch full blocks absent another means for determining which blocks contain
6294  * transactions relevant to the watched channels.
6295  */
6296 MUST_USE_RES struct LDKChainMonitor ChainMonitor_new(struct LDKFilter *chain_source, struct LDKBroadcasterInterface broadcaster, struct LDKLogger logger, struct LDKFeeEstimator feeest, struct LDKPersist persister);
6297
6298 /**
6299  * Constructs a new Watch which calls the relevant methods on this_arg.
6300  * This copies the `inner` pointer in this_arg and thus the returned Watch must be freed before this_arg is
6301  */
6302 struct LDKWatch ChainMonitor_as_Watch(const struct LDKChainMonitor *NONNULL_PTR this_arg);
6303
6304 /**
6305  * Constructs a new EventsProvider which calls the relevant methods on this_arg.
6306  * This copies the `inner` pointer in this_arg and thus the returned EventsProvider must be freed before this_arg is
6307  */
6308 struct LDKEventsProvider ChainMonitor_as_EventsProvider(const struct LDKChainMonitor *NONNULL_PTR this_arg);
6309
6310 /**
6311  * Frees any resources used by the ChannelMonitorUpdate, if is_owned is set and inner is non-NULL.
6312  */
6313 void ChannelMonitorUpdate_free(struct LDKChannelMonitorUpdate this_obj);
6314
6315 /**
6316  * The sequence number of this update. Updates *must* be replayed in-order according to this
6317  * sequence number (and updates may panic if they are not). The update_id values are strictly
6318  * increasing and increase by one for each new update, with one exception specified below.
6319  *
6320  * This sequence number is also used to track up to which points updates which returned
6321  * ChannelMonitorUpdateErr::TemporaryFailure have been applied to all copies of a given
6322  * ChannelMonitor when ChannelManager::channel_monitor_updated is called.
6323  *
6324  * The only instance where update_id values are not strictly increasing is the case where we
6325  * allow post-force-close updates with a special update ID of [`CLOSED_CHANNEL_UPDATE_ID`]. See
6326  * its docs for more details.
6327  */
6328 uint64_t ChannelMonitorUpdate_get_update_id(const struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr);
6329
6330 /**
6331  * The sequence number of this update. Updates *must* be replayed in-order according to this
6332  * sequence number (and updates may panic if they are not). The update_id values are strictly
6333  * increasing and increase by one for each new update, with one exception specified below.
6334  *
6335  * This sequence number is also used to track up to which points updates which returned
6336  * ChannelMonitorUpdateErr::TemporaryFailure have been applied to all copies of a given
6337  * ChannelMonitor when ChannelManager::channel_monitor_updated is called.
6338  *
6339  * The only instance where update_id values are not strictly increasing is the case where we
6340  * allow post-force-close updates with a special update ID of [`CLOSED_CHANNEL_UPDATE_ID`]. See
6341  * its docs for more details.
6342  */
6343 void ChannelMonitorUpdate_set_update_id(struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr, uint64_t val);
6344
6345 /**
6346  * Creates a copy of the ChannelMonitorUpdate
6347  */
6348 struct LDKChannelMonitorUpdate ChannelMonitorUpdate_clone(const struct LDKChannelMonitorUpdate *NONNULL_PTR orig);
6349
6350 /**
6351  * Serialize the ChannelMonitorUpdate object into a byte array which can be read by ChannelMonitorUpdate_read
6352  */
6353 struct LDKCVec_u8Z ChannelMonitorUpdate_write(const struct LDKChannelMonitorUpdate *NONNULL_PTR obj);
6354
6355 /**
6356  * Read a ChannelMonitorUpdate from a byte array, created by ChannelMonitorUpdate_write
6357  */
6358 struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ ChannelMonitorUpdate_read(struct LDKu8slice ser);
6359
6360 /**
6361  * Creates a copy of the ChannelMonitorUpdateErr
6362  */
6363 enum LDKChannelMonitorUpdateErr ChannelMonitorUpdateErr_clone(const enum LDKChannelMonitorUpdateErr *NONNULL_PTR orig);
6364
6365 /**
6366  * Frees any resources used by the MonitorUpdateError, if is_owned is set and inner is non-NULL.
6367  */
6368 void MonitorUpdateError_free(struct LDKMonitorUpdateError this_obj);
6369
6370 /**
6371  * Creates a copy of the MonitorUpdateError
6372  */
6373 struct LDKMonitorUpdateError MonitorUpdateError_clone(const struct LDKMonitorUpdateError *NONNULL_PTR orig);
6374
6375 /**
6376  * Frees any resources used by the MonitorEvent
6377  */
6378 void MonitorEvent_free(struct LDKMonitorEvent this_ptr);
6379
6380 /**
6381  * Creates a copy of the MonitorEvent
6382  */
6383 struct LDKMonitorEvent MonitorEvent_clone(const struct LDKMonitorEvent *NONNULL_PTR orig);
6384
6385 /**
6386  * Frees any resources used by the HTLCUpdate, if is_owned is set and inner is non-NULL.
6387  */
6388 void HTLCUpdate_free(struct LDKHTLCUpdate this_obj);
6389
6390 /**
6391  * Creates a copy of the HTLCUpdate
6392  */
6393 struct LDKHTLCUpdate HTLCUpdate_clone(const struct LDKHTLCUpdate *NONNULL_PTR orig);
6394
6395 /**
6396  * Serialize the HTLCUpdate object into a byte array which can be read by HTLCUpdate_read
6397  */
6398 struct LDKCVec_u8Z HTLCUpdate_write(const struct LDKHTLCUpdate *NONNULL_PTR obj);
6399
6400 /**
6401  * Read a HTLCUpdate from a byte array, created by HTLCUpdate_write
6402  */
6403 struct LDKCResult_HTLCUpdateDecodeErrorZ HTLCUpdate_read(struct LDKu8slice ser);
6404
6405 /**
6406  * Frees any resources used by the ChannelMonitor, if is_owned is set and inner is non-NULL.
6407  */
6408 void ChannelMonitor_free(struct LDKChannelMonitor this_obj);
6409
6410 /**
6411  * Serialize the ChannelMonitor object into a byte array which can be read by ChannelMonitor_read
6412  */
6413 struct LDKCVec_u8Z ChannelMonitor_write(const struct LDKChannelMonitor *NONNULL_PTR obj);
6414
6415 /**
6416  * Updates a ChannelMonitor on the basis of some new information provided by the Channel
6417  * itself.
6418  *
6419  * panics if the given update is not the next update by update_id.
6420  */
6421 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);
6422
6423 /**
6424  * Gets the update_id from the latest ChannelMonitorUpdate which was applied to this
6425  * ChannelMonitor.
6426  */
6427 MUST_USE_RES uint64_t ChannelMonitor_get_latest_update_id(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
6428
6429 /**
6430  * Gets the funding transaction outpoint of the channel this ChannelMonitor is monitoring for.
6431  */
6432 MUST_USE_RES struct LDKC2Tuple_OutPointScriptZ ChannelMonitor_get_funding_txo(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
6433
6434 /**
6435  * Gets a list of txids, with their output scripts (in the order they appear in the
6436  * transaction), which we must learn about spends of via block_connected().
6437  */
6438 MUST_USE_RES struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ ChannelMonitor_get_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
6439
6440 /**
6441  * Loads the funding txo and outputs to watch into the given `chain::Filter` by repeatedly
6442  * calling `chain::Filter::register_output` and `chain::Filter::register_tx` until all outputs
6443  * have been registered.
6444  */
6445 void ChannelMonitor_load_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKFilter *NONNULL_PTR filter);
6446
6447 /**
6448  * Get the list of HTLCs who's status has been updated on chain. This should be called by
6449  * ChannelManager via [`chain::Watch::release_pending_monitor_events`].
6450  */
6451 MUST_USE_RES struct LDKCVec_MonitorEventZ ChannelMonitor_get_and_clear_pending_monitor_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
6452
6453 /**
6454  * Gets the list of pending events which were generated by previous actions, clearing the list
6455  * in the process.
6456  *
6457  * This is called by ChainMonitor::get_and_clear_pending_events() and is equivalent to
6458  * EventsProvider::get_and_clear_pending_events() except that it requires &mut self as we do
6459  * no internal locking in ChannelMonitors.
6460  */
6461 MUST_USE_RES struct LDKCVec_EventZ ChannelMonitor_get_and_clear_pending_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
6462
6463 /**
6464  * Used by ChannelManager deserialization to broadcast the latest holder state if its copy of
6465  * the Channel was out-of-date. You may use it to get a broadcastable holder toxic tx in case of
6466  * fallen-behind, i.e when receiving a channel_reestablish with a proof that our counterparty side knows
6467  * a higher revocation secret than the holder commitment number we are aware of. Broadcasting these
6468  * transactions are UNSAFE, as they allow counterparty side to punish you. Nevertheless you may want to
6469  * broadcast them if counterparty don't close channel with his higher commitment transaction after a
6470  * substantial amount of time (a month or even a year) to get back funds. Best may be to contact
6471  * out-of-band the other node operator to coordinate with him if option is available to you.
6472  * In any-case, choice is up to the user.
6473  */
6474 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);
6475
6476 /**
6477  * Processes transactions in a newly connected block, which may result in any of the following:
6478  * - update the monitor's state against resolved HTLCs
6479  * - punish the counterparty in the case of seeing a revoked commitment transaction
6480  * - force close the channel and claim/timeout incoming/outgoing HTLCs if near expiration
6481  * - detect settled outputs for later spending
6482  * - schedule and bump any in-flight claims
6483  *
6484  * Returns any new outputs to watch from `txdata`; after called, these are also included in
6485  * [`get_outputs_to_watch`].
6486  *
6487  * [`get_outputs_to_watch`]: #method.get_outputs_to_watch
6488  */
6489 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);
6490
6491 /**
6492  * Determines if the disconnected block contained any transactions of interest and updates
6493  * appropriately.
6494  */
6495 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);
6496
6497 /**
6498  * Calls the free function if one is set
6499  */
6500 void Persist_free(struct LDKPersist this_ptr);
6501
6502 /**
6503  * Read a C2Tuple_BlockHashChannelMonitorZ from a byte array, created by C2Tuple_BlockHashChannelMonitorZ_write
6504  */
6505 struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ C2Tuple_BlockHashChannelMonitorZ_read(struct LDKu8slice ser, const struct LDKKeysInterface *NONNULL_PTR arg);
6506
6507 /**
6508  * Frees any resources used by the OutPoint, if is_owned is set and inner is non-NULL.
6509  */
6510 void OutPoint_free(struct LDKOutPoint this_obj);
6511
6512 /**
6513  * The referenced transaction's txid.
6514  */
6515 const uint8_t (*OutPoint_get_txid(const struct LDKOutPoint *NONNULL_PTR this_ptr))[32];
6516
6517 /**
6518  * The referenced transaction's txid.
6519  */
6520 void OutPoint_set_txid(struct LDKOutPoint *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
6521
6522 /**
6523  * The index of the referenced output in its transaction's vout.
6524  */
6525 uint16_t OutPoint_get_index(const struct LDKOutPoint *NONNULL_PTR this_ptr);
6526
6527 /**
6528  * The index of the referenced output in its transaction's vout.
6529  */
6530 void OutPoint_set_index(struct LDKOutPoint *NONNULL_PTR this_ptr, uint16_t val);
6531
6532 /**
6533  * Constructs a new OutPoint given each field
6534  */
6535 MUST_USE_RES struct LDKOutPoint OutPoint_new(struct LDKThirtyTwoBytes txid_arg, uint16_t index_arg);
6536
6537 /**
6538  * Creates a copy of the OutPoint
6539  */
6540 struct LDKOutPoint OutPoint_clone(const struct LDKOutPoint *NONNULL_PTR orig);
6541
6542 /**
6543  * Convert an `OutPoint` to a lightning channel id.
6544  */
6545 MUST_USE_RES struct LDKThirtyTwoBytes OutPoint_to_channel_id(const struct LDKOutPoint *NONNULL_PTR this_arg);
6546
6547 /**
6548  * Serialize the OutPoint object into a byte array which can be read by OutPoint_read
6549  */
6550 struct LDKCVec_u8Z OutPoint_write(const struct LDKOutPoint *NONNULL_PTR obj);
6551
6552 /**
6553  * Read a OutPoint from a byte array, created by OutPoint_write
6554  */
6555 struct LDKCResult_OutPointDecodeErrorZ OutPoint_read(struct LDKu8slice ser);
6556
6557 /**
6558  * Frees any resources used by the DelayedPaymentOutputDescriptor, if is_owned is set and inner is non-NULL.
6559  */
6560 void DelayedPaymentOutputDescriptor_free(struct LDKDelayedPaymentOutputDescriptor this_obj);
6561
6562 /**
6563  * The outpoint which is spendable
6564  */
6565 struct LDKOutPoint DelayedPaymentOutputDescriptor_get_outpoint(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
6566
6567 /**
6568  * The outpoint which is spendable
6569  */
6570 void DelayedPaymentOutputDescriptor_set_outpoint(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
6571
6572 /**
6573  * Per commitment point to derive delayed_payment_key by key holder
6574  */
6575 struct LDKPublicKey DelayedPaymentOutputDescriptor_get_per_commitment_point(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
6576
6577 /**
6578  * Per commitment point to derive delayed_payment_key by key holder
6579  */
6580 void DelayedPaymentOutputDescriptor_set_per_commitment_point(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
6581
6582 /**
6583  * The nSequence value which must be set in the spending input to satisfy the OP_CSV in
6584  * the witness_script.
6585  */
6586 uint16_t DelayedPaymentOutputDescriptor_get_to_self_delay(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
6587
6588 /**
6589  * The nSequence value which must be set in the spending input to satisfy the OP_CSV in
6590  * the witness_script.
6591  */
6592 void DelayedPaymentOutputDescriptor_set_to_self_delay(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint16_t val);
6593
6594 /**
6595  * The output which is referenced by the given outpoint
6596  */
6597 void DelayedPaymentOutputDescriptor_set_output(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
6598
6599 /**
6600  * The revocation point specific to the commitment transaction which was broadcast. Used to
6601  * derive the witnessScript for this output.
6602  */
6603 struct LDKPublicKey DelayedPaymentOutputDescriptor_get_revocation_pubkey(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
6604
6605 /**
6606  * The revocation point specific to the commitment transaction which was broadcast. Used to
6607  * derive the witnessScript for this output.
6608  */
6609 void DelayedPaymentOutputDescriptor_set_revocation_pubkey(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
6610
6611 /**
6612  * Arbitrary identification information returned by a call to
6613  * `Sign::channel_keys_id()`. This may be useful in re-deriving keys used in
6614  * the channel to spend the output.
6615  */
6616 const uint8_t (*DelayedPaymentOutputDescriptor_get_channel_keys_id(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
6617
6618 /**
6619  * Arbitrary identification information returned by a call to
6620  * `Sign::channel_keys_id()`. This may be useful in re-deriving keys used in
6621  * the channel to spend the output.
6622  */
6623 void DelayedPaymentOutputDescriptor_set_channel_keys_id(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
6624
6625 /**
6626  * The value of the channel which this output originated from, possibly indirectly.
6627  */
6628 uint64_t DelayedPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
6629
6630 /**
6631  * The value of the channel which this output originated from, possibly indirectly.
6632  */
6633 void DelayedPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
6634
6635 /**
6636  * Constructs a new DelayedPaymentOutputDescriptor given each field
6637  */
6638 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);
6639
6640 /**
6641  * Creates a copy of the DelayedPaymentOutputDescriptor
6642  */
6643 struct LDKDelayedPaymentOutputDescriptor DelayedPaymentOutputDescriptor_clone(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR orig);
6644
6645 /**
6646  * Frees any resources used by the StaticPaymentOutputDescriptor, if is_owned is set and inner is non-NULL.
6647  */
6648 void StaticPaymentOutputDescriptor_free(struct LDKStaticPaymentOutputDescriptor this_obj);
6649
6650 /**
6651  * The outpoint which is spendable
6652  */
6653 struct LDKOutPoint StaticPaymentOutputDescriptor_get_outpoint(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
6654
6655 /**
6656  * The outpoint which is spendable
6657  */
6658 void StaticPaymentOutputDescriptor_set_outpoint(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
6659
6660 /**
6661  * The output which is referenced by the given outpoint
6662  */
6663 void StaticPaymentOutputDescriptor_set_output(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut 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 (*StaticPaymentOutputDescriptor_get_channel_keys_id(const struct LDKStaticPaymentOutputDescriptor *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 StaticPaymentOutputDescriptor_set_channel_keys_id(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
6678
6679 /**
6680  * The value of the channel which this transactions spends.
6681  */
6682 uint64_t StaticPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
6683
6684 /**
6685  * The value of the channel which this transactions spends.
6686  */
6687 void StaticPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
6688
6689 /**
6690  * Constructs a new StaticPaymentOutputDescriptor given each field
6691  */
6692 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);
6693
6694 /**
6695  * Creates a copy of the StaticPaymentOutputDescriptor
6696  */
6697 struct LDKStaticPaymentOutputDescriptor StaticPaymentOutputDescriptor_clone(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR orig);
6698
6699 /**
6700  * Frees any resources used by the SpendableOutputDescriptor
6701  */
6702 void SpendableOutputDescriptor_free(struct LDKSpendableOutputDescriptor this_ptr);
6703
6704 /**
6705  * Creates a copy of the SpendableOutputDescriptor
6706  */
6707 struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_clone(const struct LDKSpendableOutputDescriptor *NONNULL_PTR orig);
6708
6709 /**
6710  * Serialize the SpendableOutputDescriptor object into a byte array which can be read by SpendableOutputDescriptor_read
6711  */
6712 struct LDKCVec_u8Z SpendableOutputDescriptor_write(const struct LDKSpendableOutputDescriptor *NONNULL_PTR obj);
6713
6714 /**
6715  * Read a SpendableOutputDescriptor from a byte array, created by SpendableOutputDescriptor_write
6716  */
6717 struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ SpendableOutputDescriptor_read(struct LDKu8slice ser);
6718
6719 /**
6720  * Creates a copy of a Sign
6721  */
6722 struct LDKSign Sign_clone(const struct LDKSign *NONNULL_PTR orig);
6723
6724 /**
6725  * Calls the free function if one is set
6726  */
6727 void Sign_free(struct LDKSign this_ptr);
6728
6729 /**
6730  * Calls the free function if one is set
6731  */
6732 void KeysInterface_free(struct LDKKeysInterface this_ptr);
6733
6734 /**
6735  * Frees any resources used by the InMemorySigner, if is_owned is set and inner is non-NULL.
6736  */
6737 void InMemorySigner_free(struct LDKInMemorySigner this_obj);
6738
6739 /**
6740  * Private key of anchor tx
6741  */
6742 const uint8_t (*InMemorySigner_get_funding_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
6743
6744 /**
6745  * Private key of anchor tx
6746  */
6747 void InMemorySigner_set_funding_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
6748
6749 /**
6750  * Holder secret key for blinded revocation pubkey
6751  */
6752 const uint8_t (*InMemorySigner_get_revocation_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
6753
6754 /**
6755  * Holder secret key for blinded revocation pubkey
6756  */
6757 void InMemorySigner_set_revocation_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
6758
6759 /**
6760  * Holder secret key used for our balance in counterparty-broadcasted commitment transactions
6761  */
6762 const uint8_t (*InMemorySigner_get_payment_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
6763
6764 /**
6765  * Holder secret key used for our balance in counterparty-broadcasted commitment transactions
6766  */
6767 void InMemorySigner_set_payment_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
6768
6769 /**
6770  * Holder secret key used in HTLC tx
6771  */
6772 const uint8_t (*InMemorySigner_get_delayed_payment_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
6773
6774 /**
6775  * Holder secret key used in HTLC tx
6776  */
6777 void InMemorySigner_set_delayed_payment_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
6778
6779 /**
6780  * Holder htlc secret key used in commitment tx htlc outputs
6781  */
6782 const uint8_t (*InMemorySigner_get_htlc_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
6783
6784 /**
6785  * Holder htlc secret key used in commitment tx htlc outputs
6786  */
6787 void InMemorySigner_set_htlc_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
6788
6789 /**
6790  * Commitment seed
6791  */
6792 const uint8_t (*InMemorySigner_get_commitment_seed(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
6793
6794 /**
6795  * Commitment seed
6796  */
6797 void InMemorySigner_set_commitment_seed(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
6798
6799 /**
6800  * Creates a copy of the InMemorySigner
6801  */
6802 struct LDKInMemorySigner InMemorySigner_clone(const struct LDKInMemorySigner *NONNULL_PTR orig);
6803
6804 /**
6805  * Create a new InMemorySigner
6806  */
6807 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);
6808
6809 /**
6810  * Counterparty pubkeys.
6811  * Will panic if ready_channel wasn't called.
6812  */
6813 MUST_USE_RES struct LDKChannelPublicKeys InMemorySigner_counterparty_pubkeys(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
6814
6815 /**
6816  * The contest_delay value specified by our counterparty and applied on holder-broadcastable
6817  * transactions, ie the amount of time that we have to wait to recover our funds if we
6818  * broadcast a transaction.
6819  * Will panic if ready_channel wasn't called.
6820  */
6821 MUST_USE_RES uint16_t InMemorySigner_counterparty_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
6822
6823 /**
6824  * The contest_delay value specified by us and applied on transactions broadcastable
6825  * by our counterparty, ie the amount of time that they have to wait to recover their funds
6826  * if they broadcast a transaction.
6827  * Will panic if ready_channel wasn't called.
6828  */
6829 MUST_USE_RES uint16_t InMemorySigner_holder_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
6830
6831 /**
6832  * Whether the holder is the initiator
6833  * Will panic if ready_channel wasn't called.
6834  */
6835 MUST_USE_RES bool InMemorySigner_is_outbound(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
6836
6837 /**
6838  * Funding outpoint
6839  * Will panic if ready_channel wasn't called.
6840  */
6841 MUST_USE_RES struct LDKOutPoint InMemorySigner_funding_outpoint(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
6842
6843 /**
6844  * Obtain a ChannelTransactionParameters for this channel, to be used when verifying or
6845  * building transactions.
6846  *
6847  * Will panic if ready_channel wasn't called.
6848  */
6849 MUST_USE_RES struct LDKChannelTransactionParameters InMemorySigner_get_channel_parameters(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
6850
6851 /**
6852  * Sign the single input of spend_tx at index `input_idx` which spends the output
6853  * described by descriptor, returning the witness stack for the input.
6854  *
6855  * Returns an Err if the input at input_idx does not exist, has a non-empty script_sig,
6856  * or is not spending the outpoint described by `descriptor.outpoint`.
6857  */
6858 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);
6859
6860 /**
6861  * Sign the single input of spend_tx at index `input_idx` which spends the output
6862  * described by descriptor, returning the witness stack for the input.
6863  *
6864  * Returns an Err if the input at input_idx does not exist, has a non-empty script_sig,
6865  * is not spending the outpoint described by `descriptor.outpoint`, or does not have a
6866  * sequence set to `descriptor.to_self_delay`.
6867  */
6868 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);
6869
6870 /**
6871  * Constructs a new Sign which calls the relevant methods on this_arg.
6872  * This copies the `inner` pointer in this_arg and thus the returned Sign must be freed before this_arg is
6873  */
6874 struct LDKSign InMemorySigner_as_Sign(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
6875
6876 /**
6877  * Serialize the InMemorySigner object into a byte array which can be read by InMemorySigner_read
6878  */
6879 struct LDKCVec_u8Z InMemorySigner_write(const struct LDKInMemorySigner *NONNULL_PTR obj);
6880
6881 /**
6882  * Read a InMemorySigner from a byte array, created by InMemorySigner_write
6883  */
6884 struct LDKCResult_InMemorySignerDecodeErrorZ InMemorySigner_read(struct LDKu8slice ser);
6885
6886 /**
6887  * Frees any resources used by the KeysManager, if is_owned is set and inner is non-NULL.
6888  */
6889 void KeysManager_free(struct LDKKeysManager this_obj);
6890
6891 /**
6892  * Constructs a KeysManager from a 32-byte seed. If the seed is in some way biased (eg your
6893  * CSRNG is busted) this may panic (but more importantly, you will possibly lose funds).
6894  * starting_time isn't strictly required to actually be a time, but it must absolutely,
6895  * without a doubt, be unique to this instance. ie if you start multiple times with the same
6896  * seed, starting_time must be unique to each run. Thus, the easiest way to achieve this is to
6897  * simply use the current time (with very high precision).
6898  *
6899  * The seed MUST be backed up safely prior to use so that the keys can be re-created, however,
6900  * obviously, starting_time should be unique every time you reload the library - it is only
6901  * used to generate new ephemeral key data (which will be stored by the individual channel if
6902  * necessary).
6903  *
6904  * Note that the seed is required to recover certain on-chain funds independent of
6905  * ChannelMonitor data, though a current copy of ChannelMonitor data is also required for any
6906  * channel, and some on-chain during-closing funds.
6907  *
6908  * Note that until the 0.1 release there is no guarantee of backward compatibility between
6909  * versions. Once the library is more fully supported, the docs will be updated to include a
6910  * detailed description of the guarantee.
6911  */
6912 MUST_USE_RES struct LDKKeysManager KeysManager_new(const uint8_t (*seed)[32], uint64_t starting_time_secs, uint32_t starting_time_nanos);
6913
6914 /**
6915  * Derive an old Sign containing per-channel secrets based on a key derivation parameters.
6916  *
6917  * Key derivation parameters are accessible through a per-channel secrets
6918  * Sign::channel_keys_id and is provided inside DynamicOuputP2WSH in case of
6919  * onchain output detection for which a corresponding delayed_payment_key must be derived.
6920  */
6921 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]);
6922
6923 /**
6924  * Creates a Transaction which spends the given descriptors to the given outputs, plus an
6925  * output to the given change destination (if sufficient change value remains). The
6926  * transaction will have a feerate, at least, of the given value.
6927  *
6928  * Returns `Err(())` if the output value is greater than the input value minus required fee or
6929  * if a descriptor was duplicated.
6930  *
6931  * We do not enforce that outputs meet the dust limit or that any output scripts are standard.
6932  *
6933  * May panic if the `SpendableOutputDescriptor`s were not generated by Channels which used
6934  * this KeysManager or one of the `InMemorySigner` created by this KeysManager.
6935  */
6936 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);
6937
6938 /**
6939  * Constructs a new KeysInterface which calls the relevant methods on this_arg.
6940  * This copies the `inner` pointer in this_arg and thus the returned KeysInterface must be freed before this_arg is
6941  */
6942 struct LDKKeysInterface KeysManager_as_KeysInterface(const struct LDKKeysManager *NONNULL_PTR this_arg);
6943
6944 /**
6945  * Frees any resources used by the ChannelManager, if is_owned is set and inner is non-NULL.
6946  */
6947 void ChannelManager_free(struct LDKChannelManager this_obj);
6948
6949 /**
6950  * Frees any resources used by the ChainParameters, if is_owned is set and inner is non-NULL.
6951  */
6952 void ChainParameters_free(struct LDKChainParameters this_obj);
6953
6954 /**
6955  * The network for determining the `chain_hash` in Lightning messages.
6956  */
6957 enum LDKNetwork ChainParameters_get_network(const struct LDKChainParameters *NONNULL_PTR this_ptr);
6958
6959 /**
6960  * The network for determining the `chain_hash` in Lightning messages.
6961  */
6962 void ChainParameters_set_network(struct LDKChainParameters *NONNULL_PTR this_ptr, enum LDKNetwork val);
6963
6964 /**
6965  * The hash of the latest block successfully connected.
6966  */
6967 const uint8_t (*ChainParameters_get_latest_hash(const struct LDKChainParameters *NONNULL_PTR this_ptr))[32];
6968
6969 /**
6970  * The hash of the latest block successfully connected.
6971  */
6972 void ChainParameters_set_latest_hash(struct LDKChainParameters *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
6973
6974 /**
6975  * The height of the latest block successfully connected.
6976  *
6977  * Used to track on-chain channel funding outputs and send payments with reliable timelocks.
6978  */
6979 uintptr_t ChainParameters_get_latest_height(const struct LDKChainParameters *NONNULL_PTR this_ptr);
6980
6981 /**
6982  * The height of the latest block successfully connected.
6983  *
6984  * Used to track on-chain channel funding outputs and send payments with reliable timelocks.
6985  */
6986 void ChainParameters_set_latest_height(struct LDKChainParameters *NONNULL_PTR this_ptr, uintptr_t val);
6987
6988 /**
6989  * Constructs a new ChainParameters given each field
6990  */
6991 MUST_USE_RES struct LDKChainParameters ChainParameters_new(enum LDKNetwork network_arg, struct LDKThirtyTwoBytes latest_hash_arg, uintptr_t latest_height_arg);
6992
6993 /**
6994  * Frees any resources used by the ChannelDetails, if is_owned is set and inner is non-NULL.
6995  */
6996 void ChannelDetails_free(struct LDKChannelDetails this_obj);
6997
6998 /**
6999  * The channel's ID (prior to funding transaction generation, this is a random 32 bytes,
7000  * thereafter this is the txid of the funding transaction xor the funding transaction output).
7001  * Note that this means this value is *not* persistent - it can change once during the
7002  * lifetime of the channel.
7003  */
7004 const uint8_t (*ChannelDetails_get_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr))[32];
7005
7006 /**
7007  * The channel's ID (prior to funding transaction generation, this is a random 32 bytes,
7008  * thereafter this is the txid of the funding transaction xor the funding transaction output).
7009  * Note that this means this value is *not* persistent - it can change once during the
7010  * lifetime of the channel.
7011  */
7012 void ChannelDetails_set_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
7013
7014 /**
7015  * The node_id of our counterparty
7016  */
7017 struct LDKPublicKey ChannelDetails_get_remote_network_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
7018
7019 /**
7020  * The node_id of our counterparty
7021  */
7022 void ChannelDetails_set_remote_network_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKPublicKey val);
7023
7024 /**
7025  * The Features the channel counterparty provided upon last connection.
7026  * Useful for routing as it is the most up-to-date copy of the counterparty's features and
7027  * many routing-relevant features are present in the init context.
7028  */
7029 struct LDKInitFeatures ChannelDetails_get_counterparty_features(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
7030
7031 /**
7032  * The Features the channel counterparty provided upon last connection.
7033  * Useful for routing as it is the most up-to-date copy of the counterparty's features and
7034  * many routing-relevant features are present in the init context.
7035  */
7036 void ChannelDetails_set_counterparty_features(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
7037
7038 /**
7039  * The value, in satoshis, of this channel as appears in the funding output
7040  */
7041 uint64_t ChannelDetails_get_channel_value_satoshis(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
7042
7043 /**
7044  * The value, in satoshis, of this channel as appears in the funding output
7045  */
7046 void ChannelDetails_set_channel_value_satoshis(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
7047
7048 /**
7049  * The user_id passed in to create_channel, or 0 if the channel was inbound.
7050  */
7051 uint64_t ChannelDetails_get_user_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
7052
7053 /**
7054  * The user_id passed in to create_channel, or 0 if the channel was inbound.
7055  */
7056 void ChannelDetails_set_user_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
7057
7058 /**
7059  * The available outbound capacity for sending HTLCs to the remote peer. This does not include
7060  * any pending HTLCs which are not yet fully resolved (and, thus, who's balance is not
7061  * available for inclusion in new outbound HTLCs). This further does not include any pending
7062  * outgoing HTLCs which are awaiting some other resolution to be sent.
7063  */
7064 uint64_t ChannelDetails_get_outbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
7065
7066 /**
7067  * The available outbound capacity for sending HTLCs to the remote peer. This does not include
7068  * any pending HTLCs which are not yet fully resolved (and, thus, who's balance is not
7069  * available for inclusion in new outbound HTLCs). This further does not include any pending
7070  * outgoing HTLCs which are awaiting some other resolution to be sent.
7071  */
7072 void ChannelDetails_set_outbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
7073
7074 /**
7075  * The available inbound capacity for the remote peer to send HTLCs to us. This does not
7076  * include any pending HTLCs which are not yet fully resolved (and, thus, who's balance is not
7077  * available for inclusion in new inbound HTLCs).
7078  * Note that there are some corner cases not fully handled here, so the actual available
7079  * inbound capacity may be slightly higher than this.
7080  */
7081 uint64_t ChannelDetails_get_inbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
7082
7083 /**
7084  * The available inbound capacity for the remote peer to send HTLCs to us. This does not
7085  * include any pending HTLCs which are not yet fully resolved (and, thus, who's balance is not
7086  * available for inclusion in new inbound HTLCs).
7087  * Note that there are some corner cases not fully handled here, so the actual available
7088  * inbound capacity may be slightly higher than this.
7089  */
7090 void ChannelDetails_set_inbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
7091
7092 /**
7093  * True if the channel is (a) confirmed and funding_locked messages have been exchanged, (b)
7094  * the peer is connected, and (c) no monitor update failure is pending resolution.
7095  */
7096 bool ChannelDetails_get_is_live(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
7097
7098 /**
7099  * True if the channel is (a) confirmed and funding_locked messages have been exchanged, (b)
7100  * the peer is connected, and (c) no monitor update failure is pending resolution.
7101  */
7102 void ChannelDetails_set_is_live(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
7103
7104 /**
7105  * Creates a copy of the ChannelDetails
7106  */
7107 struct LDKChannelDetails ChannelDetails_clone(const struct LDKChannelDetails *NONNULL_PTR orig);
7108
7109 /**
7110  * Frees any resources used by the PaymentSendFailure
7111  */
7112 void PaymentSendFailure_free(struct LDKPaymentSendFailure this_ptr);
7113
7114 /**
7115  * Creates a copy of the PaymentSendFailure
7116  */
7117 struct LDKPaymentSendFailure PaymentSendFailure_clone(const struct LDKPaymentSendFailure *NONNULL_PTR orig);
7118
7119 /**
7120  * Constructs a new ChannelManager to hold several channels and route between them.
7121  *
7122  * This is the main \"logic hub\" for all channel-related actions, and implements
7123  * ChannelMessageHandler.
7124  *
7125  * Non-proportional fees are fixed according to our risk using the provided fee estimator.
7126  *
7127  * panics if channel_value_satoshis is >= `MAX_FUNDING_SATOSHIS`!
7128  *
7129  * Users need to notify the new ChannelManager when a new block is connected or
7130  * disconnected using its `block_connected` and `block_disconnected` methods, starting
7131  * from after `params.latest_hash`.
7132  */
7133 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);
7134
7135 /**
7136  * Creates a new outbound channel to the given remote node and with the given value.
7137  *
7138  * user_id will be provided back as user_channel_id in FundingGenerationReady and
7139  * FundingBroadcastSafe events to allow tracking of which events correspond with which
7140  * create_channel call. Note that user_channel_id defaults to 0 for inbound channels, so you
7141  * may wish to avoid using 0 for user_id here.
7142  *
7143  * If successful, will generate a SendOpenChannel message event, so you should probably poll
7144  * PeerManager::process_events afterwards.
7145  *
7146  * Raises APIError::APIMisuseError when channel_value_satoshis > 2**24 or push_msat is
7147  * greater than channel_value_satoshis * 1k or channel_value_satoshis is < 1000.
7148  */
7149 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);
7150
7151 /**
7152  * Gets the list of open channels, in random order. See ChannelDetail field documentation for
7153  * more information.
7154  */
7155 MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
7156
7157 /**
7158  * Gets the list of usable channels, in random order. Useful as an argument to
7159  * get_route to ensure non-announced channels are used.
7160  *
7161  * These are guaranteed to have their is_live value set to true, see the documentation for
7162  * ChannelDetails::is_live for more info on exactly what the criteria are.
7163  */
7164 MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_usable_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
7165
7166 /**
7167  * Begins the process of closing a channel. After this call (plus some timeout), no new HTLCs
7168  * will be accepted on the given channel, and after additional timeout/the closing of all
7169  * pending HTLCs, the channel will be closed on chain.
7170  *
7171  * May generate a SendShutdown message event on success, which should be relayed.
7172  */
7173 MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_close_channel(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*channel_id)[32]);
7174
7175 /**
7176  * Force closes a channel, immediately broadcasting the latest local commitment transaction to
7177  * the chain and rejecting new HTLCs on the given channel. Fails if channel_id is unknown to the manager.
7178  */
7179 MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_force_close_channel(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*channel_id)[32]);
7180
7181 /**
7182  * Force close all channels, immediately broadcasting the latest local commitment transaction
7183  * for each to the chain and rejecting new HTLCs on each.
7184  */
7185 void ChannelManager_force_close_all_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
7186
7187 /**
7188  * Sends a payment along a given route.
7189  *
7190  * Value parameters are provided via the last hop in route, see documentation for RouteHop
7191  * fields for more info.
7192  *
7193  * Note that if the payment_hash already exists elsewhere (eg you're sending a duplicative
7194  * payment), we don't do anything to stop you! We always try to ensure that if the provided
7195  * next hop knows the preimage to payment_hash they can claim an additional amount as
7196  * specified in the last hop in the route! Thus, you should probably do your own
7197  * payment_preimage tracking (which you should already be doing as they represent \"proof of
7198  * payment\") and prevent double-sends yourself.
7199  *
7200  * May generate SendHTLCs message(s) event on success, which should be relayed.
7201  *
7202  * Each path may have a different return value, and PaymentSendValue may return a Vec with
7203  * each entry matching the corresponding-index entry in the route paths, see
7204  * PaymentSendFailure for more info.
7205  *
7206  * In general, a path may raise:
7207  *  * APIError::RouteError when an invalid route or forwarding parameter (cltv_delta, fee,
7208  *    node public key) is specified.
7209  *  * APIError::ChannelUnavailable if the next-hop channel is not available for updates
7210  *    (including due to previous monitor update failure or new permanent monitor update
7211  *    failure).
7212  *  * APIError::MonitorUpdateFailed if a new monitor update failure prevented sending the
7213  *    relevant updates.
7214  *
7215  * Note that depending on the type of the PaymentSendFailure the HTLC may have been
7216  * irrevocably committed to on our end. In such a case, do NOT retry the payment with a
7217  * different route unless you intend to pay twice!
7218  *
7219  * payment_secret is unrelated to payment_hash (or PaymentPreimage) and exists to authenticate
7220  * the sender to the recipient and prevent payment-probing (deanonymization) attacks. For
7221  * newer nodes, it will be provided to you in the invoice. If you do not have one, the Route
7222  * must not contain multiple paths as multi-path payments require a recipient-provided
7223  * payment_secret.
7224  * If a payment_secret *is* provided, we assume that the invoice had the payment_secret feature
7225  * bit set (either as required or as available). If multiple paths are present in the Route,
7226  * we assume the invoice had the basic_mpp feature set.
7227  */
7228 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);
7229
7230 /**
7231  * Call this upon creation of a funding transaction for the given channel.
7232  *
7233  * Note that ALL inputs in the transaction pointed to by funding_txo MUST spend SegWit outputs
7234  * or your counterparty can steal your funds!
7235  *
7236  * Panics if a funding transaction has already been provided for this channel.
7237  *
7238  * May panic if the funding_txo is duplicative with some other channel (note that this should
7239  * be trivially prevented by using unique funding transaction keys per-channel).
7240  */
7241 void ChannelManager_funding_transaction_generated(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*temporary_channel_id)[32], struct LDKOutPoint funding_txo);
7242
7243 /**
7244  * Generates a signed node_announcement from the given arguments and creates a
7245  * BroadcastNodeAnnouncement event. Note that such messages will be ignored unless peers have
7246  * seen a channel_announcement from us (ie unless we have public channels open).
7247  *
7248  * RGB is a node \"color\" and alias is a printable human-readable string to describe this node
7249  * to humans. They carry no in-protocol meaning.
7250  *
7251  * addresses represent the set (possibly empty) of socket addresses on which this node accepts
7252  * incoming connections. These will be broadcast to the network, publicly tying these
7253  * addresses together. If you wish to preserve user privacy, addresses should likely contain
7254  * only Tor Onion addresses.
7255  *
7256  * Panics if addresses is absurdly large (more than 500).
7257  */
7258 void ChannelManager_broadcast_node_announcement(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThreeBytes rgb, struct LDKThirtyTwoBytes alias, struct LDKCVec_NetAddressZ addresses);
7259
7260 /**
7261  * Processes HTLCs which are pending waiting on random forward delay.
7262  *
7263  * Should only really ever be called in response to a PendingHTLCsForwardable event.
7264  * Will likely generate further events.
7265  */
7266 void ChannelManager_process_pending_htlc_forwards(const struct LDKChannelManager *NONNULL_PTR this_arg);
7267
7268 /**
7269  * If a peer is disconnected we mark any channels with that peer as 'disabled'.
7270  * After some time, if channels are still disabled we need to broadcast a ChannelUpdate
7271  * to inform the network about the uselessness of these channels.
7272  *
7273  * This method handles all the details, and must be called roughly once per minute.
7274  *
7275  * Note that in some rare cases this may generate a `chain::Watch::update_channel` call.
7276  */
7277 void ChannelManager_timer_chan_freshness_every_min(const struct LDKChannelManager *NONNULL_PTR this_arg);
7278
7279 /**
7280  * Indicates that the preimage for payment_hash is unknown or the received amount is incorrect
7281  * after a PaymentReceived event, failing the HTLC back to its origin and freeing resources
7282  * along the path (including in our own channel on which we received it).
7283  * Returns false if no payment was found to fail backwards, true if the process of failing the
7284  * HTLC backwards has been started.
7285  */
7286 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);
7287
7288 /**
7289  * Provides a payment preimage in response to a PaymentReceived event, returning true and
7290  * generating message events for the net layer to claim the payment, if possible. Thus, you
7291  * should probably kick the net layer to go send messages if this returns true!
7292  *
7293  * You must specify the expected amounts for this HTLC, and we will only claim HTLCs
7294  * available within a few percent of the expected amount. This is critical for several
7295  * reasons : a) it avoids providing senders with `proof-of-payment` (in the form of the
7296  * payment_preimage without having provided the full value and b) it avoids certain
7297  * privacy-breaking recipient-probing attacks which may reveal payment activity to
7298  * motivated attackers.
7299  *
7300  * Note that the privacy concerns in (b) are not relevant in payments with a payment_secret
7301  * set. Thus, for such payments we will claim any payments which do not under-pay.
7302  *
7303  * May panic if called except in response to a PaymentReceived event.
7304  */
7305 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);
7306
7307 /**
7308  * Gets the node_id held by this ChannelManager
7309  */
7310 MUST_USE_RES struct LDKPublicKey ChannelManager_get_our_node_id(const struct LDKChannelManager *NONNULL_PTR this_arg);
7311
7312 /**
7313  * Restores a single, given channel to normal operation after a
7314  * ChannelMonitorUpdateErr::TemporaryFailure was returned from a channel monitor update
7315  * operation.
7316  *
7317  * All ChannelMonitor updates up to and including highest_applied_update_id must have been
7318  * fully committed in every copy of the given channels' ChannelMonitors.
7319  *
7320  * Note that there is no effect to calling with a highest_applied_update_id other than the
7321  * current latest ChannelMonitorUpdate and one call to this function after multiple
7322  * ChannelMonitorUpdateErr::TemporaryFailures is fine. The highest_applied_update_id field
7323  * exists largely only to prevent races between this and concurrent update_monitor calls.
7324  *
7325  * Thus, the anticipated use is, at a high level:
7326  *  1) You register a chain::Watch with this ChannelManager,
7327  *  2) it stores each update to disk, and begins updating any remote (eg watchtower) copies of
7328  *     said ChannelMonitors as it can, returning ChannelMonitorUpdateErr::TemporaryFailures
7329  *     any time it cannot do so instantly,
7330  *  3) update(s) are applied to each remote copy of a ChannelMonitor,
7331  *  4) once all remote copies are updated, you call this function with the update_id that
7332  *     completed, and once it is the latest the Channel will be re-enabled.
7333  */
7334 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);
7335
7336 /**
7337  * Constructs a new MessageSendEventsProvider which calls the relevant methods on this_arg.
7338  * This copies the `inner` pointer in this_arg and thus the returned MessageSendEventsProvider must be freed before this_arg is
7339  */
7340 struct LDKMessageSendEventsProvider ChannelManager_as_MessageSendEventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
7341
7342 /**
7343  * Constructs a new EventsProvider which calls the relevant methods on this_arg.
7344  * This copies the `inner` pointer in this_arg and thus the returned EventsProvider must be freed before this_arg is
7345  */
7346 struct LDKEventsProvider ChannelManager_as_EventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
7347
7348 /**
7349  * Constructs a new Listen which calls the relevant methods on this_arg.
7350  * This copies the `inner` pointer in this_arg and thus the returned Listen must be freed before this_arg is
7351  */
7352 struct LDKListen ChannelManager_as_Listen(const struct LDKChannelManager *NONNULL_PTR this_arg);
7353
7354 /**
7355  * Updates channel state based on transactions seen in a connected block.
7356  */
7357 void ChannelManager_block_connected(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height);
7358
7359 /**
7360  * Updates channel state based on a disconnected block.
7361  *
7362  * If necessary, the channel may be force-closed without letting the counterparty participate
7363  * in the shutdown.
7364  */
7365 void ChannelManager_block_disconnected(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*header)[80]);
7366
7367 /**
7368  * Blocks until ChannelManager needs to be persisted. Only one listener on
7369  * `await_persistable_update` or `await_persistable_update_timeout` is guaranteed to be woken
7370  * up.
7371  */
7372 void ChannelManager_await_persistable_update(const struct LDKChannelManager *NONNULL_PTR this_arg);
7373
7374 /**
7375  * Constructs a new ChannelMessageHandler which calls the relevant methods on this_arg.
7376  * This copies the `inner` pointer in this_arg and thus the returned ChannelMessageHandler must be freed before this_arg is
7377  */
7378 struct LDKChannelMessageHandler ChannelManager_as_ChannelMessageHandler(const struct LDKChannelManager *NONNULL_PTR this_arg);
7379
7380 /**
7381  * Serialize the ChannelManager object into a byte array which can be read by ChannelManager_read
7382  */
7383 struct LDKCVec_u8Z ChannelManager_write(const struct LDKChannelManager *NONNULL_PTR obj);
7384
7385 /**
7386  * Frees any resources used by the ChannelManagerReadArgs, if is_owned is set and inner is non-NULL.
7387  */
7388 void ChannelManagerReadArgs_free(struct LDKChannelManagerReadArgs this_obj);
7389
7390 /**
7391  * The keys provider which will give us relevant keys. Some keys will be loaded during
7392  * deserialization and KeysInterface::read_chan_signer will be used to read per-Channel
7393  * signing data.
7394  */
7395 const struct LDKKeysInterface *ChannelManagerReadArgs_get_keys_manager(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
7396
7397 /**
7398  * The keys provider which will give us relevant keys. Some keys will be loaded during
7399  * deserialization and KeysInterface::read_chan_signer will be used to read per-Channel
7400  * signing data.
7401  */
7402 void ChannelManagerReadArgs_set_keys_manager(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKKeysInterface val);
7403
7404 /**
7405  * The fee_estimator for use in the ChannelManager in the future.
7406  *
7407  * No calls to the FeeEstimator will be made during deserialization.
7408  */
7409 const struct LDKFeeEstimator *ChannelManagerReadArgs_get_fee_estimator(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
7410
7411 /**
7412  * The fee_estimator for use in the ChannelManager in the future.
7413  *
7414  * No calls to the FeeEstimator will be made during deserialization.
7415  */
7416 void ChannelManagerReadArgs_set_fee_estimator(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKFeeEstimator val);
7417
7418 /**
7419  * The chain::Watch for use in the ChannelManager in the future.
7420  *
7421  * No calls to the chain::Watch will be made during deserialization. It is assumed that
7422  * you have deserialized ChannelMonitors separately and will add them to your
7423  * chain::Watch after deserializing this ChannelManager.
7424  */
7425 const struct LDKWatch *ChannelManagerReadArgs_get_chain_monitor(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
7426
7427 /**
7428  * The chain::Watch for use in the ChannelManager in the future.
7429  *
7430  * No calls to the chain::Watch will be made during deserialization. It is assumed that
7431  * you have deserialized ChannelMonitors separately and will add them to your
7432  * chain::Watch after deserializing this ChannelManager.
7433  */
7434 void ChannelManagerReadArgs_set_chain_monitor(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKWatch val);
7435
7436 /**
7437  * The BroadcasterInterface which will be used in the ChannelManager in the future and may be
7438  * used to broadcast the latest local commitment transactions of channels which must be
7439  * force-closed during deserialization.
7440  */
7441 const struct LDKBroadcasterInterface *ChannelManagerReadArgs_get_tx_broadcaster(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
7442
7443 /**
7444  * The BroadcasterInterface which will be used in the ChannelManager in the future and may be
7445  * used to broadcast the latest local commitment transactions of channels which must be
7446  * force-closed during deserialization.
7447  */
7448 void ChannelManagerReadArgs_set_tx_broadcaster(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKBroadcasterInterface val);
7449
7450 /**
7451  * The Logger for use in the ChannelManager and which may be used to log information during
7452  * deserialization.
7453  */
7454 const struct LDKLogger *ChannelManagerReadArgs_get_logger(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
7455
7456 /**
7457  * The Logger for use in the ChannelManager and which may be used to log information during
7458  * deserialization.
7459  */
7460 void ChannelManagerReadArgs_set_logger(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKLogger val);
7461
7462 /**
7463  * Default settings used for new channels. Any existing channels will continue to use the
7464  * runtime settings which were stored when the ChannelManager was serialized.
7465  */
7466 struct LDKUserConfig ChannelManagerReadArgs_get_default_config(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
7467
7468 /**
7469  * Default settings used for new channels. Any existing channels will continue to use the
7470  * runtime settings which were stored when the ChannelManager was serialized.
7471  */
7472 void ChannelManagerReadArgs_set_default_config(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKUserConfig val);
7473
7474 /**
7475  * Simple utility function to create a ChannelManagerReadArgs which creates the monitor
7476  * HashMap for you. This is primarily useful for C bindings where it is not practical to
7477  * populate a HashMap directly from C.
7478  */
7479 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);
7480
7481 /**
7482  * Read a C2Tuple_BlockHashChannelManagerZ from a byte array, created by C2Tuple_BlockHashChannelManagerZ_write
7483  */
7484 struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ C2Tuple_BlockHashChannelManagerZ_read(struct LDKu8slice ser, struct LDKChannelManagerReadArgs arg);
7485
7486 /**
7487  * Frees any resources used by the DecodeError, if is_owned is set and inner is non-NULL.
7488  */
7489 void DecodeError_free(struct LDKDecodeError this_obj);
7490
7491 /**
7492  * Creates a copy of the DecodeError
7493  */
7494 struct LDKDecodeError DecodeError_clone(const struct LDKDecodeError *NONNULL_PTR orig);
7495
7496 /**
7497  * Frees any resources used by the Init, if is_owned is set and inner is non-NULL.
7498  */
7499 void Init_free(struct LDKInit this_obj);
7500
7501 /**
7502  * The relevant features which the sender supports
7503  */
7504 struct LDKInitFeatures Init_get_features(const struct LDKInit *NONNULL_PTR this_ptr);
7505
7506 /**
7507  * The relevant features which the sender supports
7508  */
7509 void Init_set_features(struct LDKInit *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
7510
7511 /**
7512  * Constructs a new Init given each field
7513  */
7514 MUST_USE_RES struct LDKInit Init_new(struct LDKInitFeatures features_arg);
7515
7516 /**
7517  * Creates a copy of the Init
7518  */
7519 struct LDKInit Init_clone(const struct LDKInit *NONNULL_PTR orig);
7520
7521 /**
7522  * Frees any resources used by the ErrorMessage, if is_owned is set and inner is non-NULL.
7523  */
7524 void ErrorMessage_free(struct LDKErrorMessage this_obj);
7525
7526 /**
7527  * The channel ID involved in the error
7528  */
7529 const uint8_t (*ErrorMessage_get_channel_id(const struct LDKErrorMessage *NONNULL_PTR this_ptr))[32];
7530
7531 /**
7532  * The channel ID involved in the error
7533  */
7534 void ErrorMessage_set_channel_id(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
7535
7536 /**
7537  * A possibly human-readable error description.
7538  * The string should be sanitized before it is used (e.g. emitted to logs
7539  * or printed to stdout).  Otherwise, a well crafted error message may trigger a security
7540  * vulnerability in the terminal emulator or the logging subsystem.
7541  */
7542 struct LDKStr ErrorMessage_get_data(const struct LDKErrorMessage *NONNULL_PTR this_ptr);
7543
7544 /**
7545  * A possibly human-readable error description.
7546  * The string should be sanitized before it is used (e.g. emitted to logs
7547  * or printed to stdout).  Otherwise, a well crafted error message may trigger a security
7548  * vulnerability in the terminal emulator or the logging subsystem.
7549  */
7550 void ErrorMessage_set_data(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
7551
7552 /**
7553  * Constructs a new ErrorMessage given each field
7554  */
7555 MUST_USE_RES struct LDKErrorMessage ErrorMessage_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKCVec_u8Z data_arg);
7556
7557 /**
7558  * Creates a copy of the ErrorMessage
7559  */
7560 struct LDKErrorMessage ErrorMessage_clone(const struct LDKErrorMessage *NONNULL_PTR orig);
7561
7562 /**
7563  * Frees any resources used by the Ping, if is_owned is set and inner is non-NULL.
7564  */
7565 void Ping_free(struct LDKPing this_obj);
7566
7567 /**
7568  * The desired response length
7569  */
7570 uint16_t Ping_get_ponglen(const struct LDKPing *NONNULL_PTR this_ptr);
7571
7572 /**
7573  * The desired response length
7574  */
7575 void Ping_set_ponglen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
7576
7577 /**
7578  * The ping packet size.
7579  * This field is not sent on the wire. byteslen zeros are sent.
7580  */
7581 uint16_t Ping_get_byteslen(const struct LDKPing *NONNULL_PTR this_ptr);
7582
7583 /**
7584  * The ping packet size.
7585  * This field is not sent on the wire. byteslen zeros are sent.
7586  */
7587 void Ping_set_byteslen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
7588
7589 /**
7590  * Constructs a new Ping given each field
7591  */
7592 MUST_USE_RES struct LDKPing Ping_new(uint16_t ponglen_arg, uint16_t byteslen_arg);
7593
7594 /**
7595  * Creates a copy of the Ping
7596  */
7597 struct LDKPing Ping_clone(const struct LDKPing *NONNULL_PTR orig);
7598
7599 /**
7600  * Frees any resources used by the Pong, if is_owned is set and inner is non-NULL.
7601  */
7602 void Pong_free(struct LDKPong this_obj);
7603
7604 /**
7605  * The pong packet size.
7606  * This field is not sent on the wire. byteslen zeros are sent.
7607  */
7608 uint16_t Pong_get_byteslen(const struct LDKPong *NONNULL_PTR this_ptr);
7609
7610 /**
7611  * The pong packet size.
7612  * This field is not sent on the wire. byteslen zeros are sent.
7613  */
7614 void Pong_set_byteslen(struct LDKPong *NONNULL_PTR this_ptr, uint16_t val);
7615
7616 /**
7617  * Constructs a new Pong given each field
7618  */
7619 MUST_USE_RES struct LDKPong Pong_new(uint16_t byteslen_arg);
7620
7621 /**
7622  * Creates a copy of the Pong
7623  */
7624 struct LDKPong Pong_clone(const struct LDKPong *NONNULL_PTR orig);
7625
7626 /**
7627  * Frees any resources used by the OpenChannel, if is_owned is set and inner is non-NULL.
7628  */
7629 void OpenChannel_free(struct LDKOpenChannel this_obj);
7630
7631 /**
7632  * The genesis hash of the blockchain where the channel is to be opened
7633  */
7634 const uint8_t (*OpenChannel_get_chain_hash(const struct LDKOpenChannel *NONNULL_PTR this_ptr))[32];
7635
7636 /**
7637  * The genesis hash of the blockchain where the channel is to be opened
7638  */
7639 void OpenChannel_set_chain_hash(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
7640
7641 /**
7642  * A temporary channel ID, until the funding outpoint is announced
7643  */
7644 const uint8_t (*OpenChannel_get_temporary_channel_id(const struct LDKOpenChannel *NONNULL_PTR this_ptr))[32];
7645
7646 /**
7647  * A temporary channel ID, until the funding outpoint is announced
7648  */
7649 void OpenChannel_set_temporary_channel_id(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
7650
7651 /**
7652  * The channel value
7653  */
7654 uint64_t OpenChannel_get_funding_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
7655
7656 /**
7657  * The channel value
7658  */
7659 void OpenChannel_set_funding_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
7660
7661 /**
7662  * The amount to push to the counterparty as part of the open, in milli-satoshi
7663  */
7664 uint64_t OpenChannel_get_push_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
7665
7666 /**
7667  * The amount to push to the counterparty as part of the open, in milli-satoshi
7668  */
7669 void OpenChannel_set_push_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
7670
7671 /**
7672  * The threshold below which outputs on transactions broadcast by sender will be omitted
7673  */
7674 uint64_t OpenChannel_get_dust_limit_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
7675
7676 /**
7677  * The threshold below which outputs on transactions broadcast by sender will be omitted
7678  */
7679 void OpenChannel_set_dust_limit_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
7680
7681 /**
7682  * The maximum inbound HTLC value in flight towards sender, in milli-satoshi
7683  */
7684 uint64_t OpenChannel_get_max_htlc_value_in_flight_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
7685
7686 /**
7687  * The maximum inbound HTLC value in flight towards sender, in milli-satoshi
7688  */
7689 void OpenChannel_set_max_htlc_value_in_flight_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
7690
7691 /**
7692  * The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
7693  */
7694 uint64_t OpenChannel_get_channel_reserve_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
7695
7696 /**
7697  * The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
7698  */
7699 void OpenChannel_set_channel_reserve_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
7700
7701 /**
7702  * The minimum HTLC size incoming to sender, in milli-satoshi
7703  */
7704 uint64_t OpenChannel_get_htlc_minimum_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
7705
7706 /**
7707  * The minimum HTLC size incoming to sender, in milli-satoshi
7708  */
7709 void OpenChannel_set_htlc_minimum_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
7710
7711 /**
7712  * The feerate per 1000-weight of sender generated transactions, until updated by update_fee
7713  */
7714 uint32_t OpenChannel_get_feerate_per_kw(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
7715
7716 /**
7717  * The feerate per 1000-weight of sender generated transactions, until updated by update_fee
7718  */
7719 void OpenChannel_set_feerate_per_kw(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint32_t val);
7720
7721 /**
7722  * The number of blocks which the counterparty will have to wait to claim on-chain funds if they broadcast a commitment transaction
7723  */
7724 uint16_t OpenChannel_get_to_self_delay(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
7725
7726 /**
7727  * The number of blocks which the counterparty will have to wait to claim on-chain funds if they broadcast a commitment transaction
7728  */
7729 void OpenChannel_set_to_self_delay(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint16_t val);
7730
7731 /**
7732  * The maximum number of inbound HTLCs towards sender
7733  */
7734 uint16_t OpenChannel_get_max_accepted_htlcs(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
7735
7736 /**
7737  * The maximum number of inbound HTLCs towards sender
7738  */
7739 void OpenChannel_set_max_accepted_htlcs(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint16_t val);
7740
7741 /**
7742  * The sender's key controlling the funding transaction
7743  */
7744 struct LDKPublicKey OpenChannel_get_funding_pubkey(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
7745
7746 /**
7747  * The sender's key controlling the funding transaction
7748  */
7749 void OpenChannel_set_funding_pubkey(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
7750
7751 /**
7752  * Used to derive a revocation key for transactions broadcast by counterparty
7753  */
7754 struct LDKPublicKey OpenChannel_get_revocation_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
7755
7756 /**
7757  * Used to derive a revocation key for transactions broadcast by counterparty
7758  */
7759 void OpenChannel_set_revocation_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
7760
7761 /**
7762  * A payment key to sender for transactions broadcast by counterparty
7763  */
7764 struct LDKPublicKey OpenChannel_get_payment_point(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
7765
7766 /**
7767  * A payment key to sender for transactions broadcast by counterparty
7768  */
7769 void OpenChannel_set_payment_point(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
7770
7771 /**
7772  * Used to derive a payment key to sender for transactions broadcast by sender
7773  */
7774 struct LDKPublicKey OpenChannel_get_delayed_payment_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
7775
7776 /**
7777  * Used to derive a payment key to sender for transactions broadcast by sender
7778  */
7779 void OpenChannel_set_delayed_payment_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
7780
7781 /**
7782  * Used to derive an HTLC payment key to sender
7783  */
7784 struct LDKPublicKey OpenChannel_get_htlc_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
7785
7786 /**
7787  * Used to derive an HTLC payment key to sender
7788  */
7789 void OpenChannel_set_htlc_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
7790
7791 /**
7792  * The first to-be-broadcast-by-sender transaction's per commitment point
7793  */
7794 struct LDKPublicKey OpenChannel_get_first_per_commitment_point(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
7795
7796 /**
7797  * The first to-be-broadcast-by-sender transaction's per commitment point
7798  */
7799 void OpenChannel_set_first_per_commitment_point(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
7800
7801 /**
7802  * Channel flags
7803  */
7804 uint8_t OpenChannel_get_channel_flags(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
7805
7806 /**
7807  * Channel flags
7808  */
7809 void OpenChannel_set_channel_flags(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint8_t val);
7810
7811 /**
7812  * Creates a copy of the OpenChannel
7813  */
7814 struct LDKOpenChannel OpenChannel_clone(const struct LDKOpenChannel *NONNULL_PTR orig);
7815
7816 /**
7817  * Frees any resources used by the AcceptChannel, if is_owned is set and inner is non-NULL.
7818  */
7819 void AcceptChannel_free(struct LDKAcceptChannel this_obj);
7820
7821 /**
7822  * A temporary channel ID, until the funding outpoint is announced
7823  */
7824 const uint8_t (*AcceptChannel_get_temporary_channel_id(const struct LDKAcceptChannel *NONNULL_PTR this_ptr))[32];
7825
7826 /**
7827  * A temporary channel ID, until the funding outpoint is announced
7828  */
7829 void AcceptChannel_set_temporary_channel_id(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
7830
7831 /**
7832  * The threshold below which outputs on transactions broadcast by sender will be omitted
7833  */
7834 uint64_t AcceptChannel_get_dust_limit_satoshis(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
7835
7836 /**
7837  * The threshold below which outputs on transactions broadcast by sender will be omitted
7838  */
7839 void AcceptChannel_set_dust_limit_satoshis(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
7840
7841 /**
7842  * The maximum inbound HTLC value in flight towards sender, in milli-satoshi
7843  */
7844 uint64_t AcceptChannel_get_max_htlc_value_in_flight_msat(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
7845
7846 /**
7847  * The maximum inbound HTLC value in flight towards sender, in milli-satoshi
7848  */
7849 void AcceptChannel_set_max_htlc_value_in_flight_msat(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
7850
7851 /**
7852  * The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
7853  */
7854 uint64_t AcceptChannel_get_channel_reserve_satoshis(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
7855
7856 /**
7857  * The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
7858  */
7859 void AcceptChannel_set_channel_reserve_satoshis(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
7860
7861 /**
7862  * The minimum HTLC size incoming to sender, in milli-satoshi
7863  */
7864 uint64_t AcceptChannel_get_htlc_minimum_msat(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
7865
7866 /**
7867  * The minimum HTLC size incoming to sender, in milli-satoshi
7868  */
7869 void AcceptChannel_set_htlc_minimum_msat(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
7870
7871 /**
7872  * Minimum depth of the funding transaction before the channel is considered open
7873  */
7874 uint32_t AcceptChannel_get_minimum_depth(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
7875
7876 /**
7877  * Minimum depth of the funding transaction before the channel is considered open
7878  */
7879 void AcceptChannel_set_minimum_depth(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint32_t val);
7880
7881 /**
7882  * The number of blocks which the counterparty will have to wait to claim on-chain funds if they broadcast a commitment transaction
7883  */
7884 uint16_t AcceptChannel_get_to_self_delay(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
7885
7886 /**
7887  * The number of blocks which the counterparty will have to wait to claim on-chain funds if they broadcast a commitment transaction
7888  */
7889 void AcceptChannel_set_to_self_delay(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint16_t val);
7890
7891 /**
7892  * The maximum number of inbound HTLCs towards sender
7893  */
7894 uint16_t AcceptChannel_get_max_accepted_htlcs(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
7895
7896 /**
7897  * The maximum number of inbound HTLCs towards sender
7898  */
7899 void AcceptChannel_set_max_accepted_htlcs(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint16_t val);
7900
7901 /**
7902  * The sender's key controlling the funding transaction
7903  */
7904 struct LDKPublicKey AcceptChannel_get_funding_pubkey(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
7905
7906 /**
7907  * The sender's key controlling the funding transaction
7908  */
7909 void AcceptChannel_set_funding_pubkey(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
7910
7911 /**
7912  * Used to derive a revocation key for transactions broadcast by counterparty
7913  */
7914 struct LDKPublicKey AcceptChannel_get_revocation_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
7915
7916 /**
7917  * Used to derive a revocation key for transactions broadcast by counterparty
7918  */
7919 void AcceptChannel_set_revocation_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
7920
7921 /**
7922  * A payment key to sender for transactions broadcast by counterparty
7923  */
7924 struct LDKPublicKey AcceptChannel_get_payment_point(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
7925
7926 /**
7927  * A payment key to sender for transactions broadcast by counterparty
7928  */
7929 void AcceptChannel_set_payment_point(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
7930
7931 /**
7932  * Used to derive a payment key to sender for transactions broadcast by sender
7933  */
7934 struct LDKPublicKey AcceptChannel_get_delayed_payment_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
7935
7936 /**
7937  * Used to derive a payment key to sender for transactions broadcast by sender
7938  */
7939 void AcceptChannel_set_delayed_payment_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
7940
7941 /**
7942  * Used to derive an HTLC payment key to sender for transactions broadcast by counterparty
7943  */
7944 struct LDKPublicKey AcceptChannel_get_htlc_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
7945
7946 /**
7947  * Used to derive an HTLC payment key to sender for transactions broadcast by counterparty
7948  */
7949 void AcceptChannel_set_htlc_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
7950
7951 /**
7952  * The first to-be-broadcast-by-sender transaction's per commitment point
7953  */
7954 struct LDKPublicKey AcceptChannel_get_first_per_commitment_point(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
7955
7956 /**
7957  * The first to-be-broadcast-by-sender transaction's per commitment point
7958  */
7959 void AcceptChannel_set_first_per_commitment_point(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
7960
7961 /**
7962  * Creates a copy of the AcceptChannel
7963  */
7964 struct LDKAcceptChannel AcceptChannel_clone(const struct LDKAcceptChannel *NONNULL_PTR orig);
7965
7966 /**
7967  * Frees any resources used by the FundingCreated, if is_owned is set and inner is non-NULL.
7968  */
7969 void FundingCreated_free(struct LDKFundingCreated this_obj);
7970
7971 /**
7972  * A temporary channel ID, until the funding is established
7973  */
7974 const uint8_t (*FundingCreated_get_temporary_channel_id(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
7975
7976 /**
7977  * A temporary channel ID, until the funding is established
7978  */
7979 void FundingCreated_set_temporary_channel_id(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
7980
7981 /**
7982  * The funding transaction ID
7983  */
7984 const uint8_t (*FundingCreated_get_funding_txid(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
7985
7986 /**
7987  * The funding transaction ID
7988  */
7989 void FundingCreated_set_funding_txid(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
7990
7991 /**
7992  * The specific output index funding this channel
7993  */
7994 uint16_t FundingCreated_get_funding_output_index(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
7995
7996 /**
7997  * The specific output index funding this channel
7998  */
7999 void FundingCreated_set_funding_output_index(struct LDKFundingCreated *NONNULL_PTR this_ptr, uint16_t val);
8000
8001 /**
8002  * The signature of the channel initiator (funder) on the funding transaction
8003  */
8004 struct LDKSignature FundingCreated_get_signature(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
8005
8006 /**
8007  * The signature of the channel initiator (funder) on the funding transaction
8008  */
8009 void FundingCreated_set_signature(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKSignature val);
8010
8011 /**
8012  * Constructs a new FundingCreated given each field
8013  */
8014 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);
8015
8016 /**
8017  * Creates a copy of the FundingCreated
8018  */
8019 struct LDKFundingCreated FundingCreated_clone(const struct LDKFundingCreated *NONNULL_PTR orig);
8020
8021 /**
8022  * Frees any resources used by the FundingSigned, if is_owned is set and inner is non-NULL.
8023  */
8024 void FundingSigned_free(struct LDKFundingSigned this_obj);
8025
8026 /**
8027  * The channel ID
8028  */
8029 const uint8_t (*FundingSigned_get_channel_id(const struct LDKFundingSigned *NONNULL_PTR this_ptr))[32];
8030
8031 /**
8032  * The channel ID
8033  */
8034 void FundingSigned_set_channel_id(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
8035
8036 /**
8037  * The signature of the channel acceptor (fundee) on the funding transaction
8038  */
8039 struct LDKSignature FundingSigned_get_signature(const struct LDKFundingSigned *NONNULL_PTR this_ptr);
8040
8041 /**
8042  * The signature of the channel acceptor (fundee) on the funding transaction
8043  */
8044 void FundingSigned_set_signature(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
8045
8046 /**
8047  * Constructs a new FundingSigned given each field
8048  */
8049 MUST_USE_RES struct LDKFundingSigned FundingSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKSignature signature_arg);
8050
8051 /**
8052  * Creates a copy of the FundingSigned
8053  */
8054 struct LDKFundingSigned FundingSigned_clone(const struct LDKFundingSigned *NONNULL_PTR orig);
8055
8056 /**
8057  * Frees any resources used by the FundingLocked, if is_owned is set and inner is non-NULL.
8058  */
8059 void FundingLocked_free(struct LDKFundingLocked this_obj);
8060
8061 /**
8062  * The channel ID
8063  */
8064 const uint8_t (*FundingLocked_get_channel_id(const struct LDKFundingLocked *NONNULL_PTR this_ptr))[32];
8065
8066 /**
8067  * The channel ID
8068  */
8069 void FundingLocked_set_channel_id(struct LDKFundingLocked *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
8070
8071 /**
8072  * The per-commitment point of the second commitment transaction
8073  */
8074 struct LDKPublicKey FundingLocked_get_next_per_commitment_point(const struct LDKFundingLocked *NONNULL_PTR this_ptr);
8075
8076 /**
8077  * The per-commitment point of the second commitment transaction
8078  */
8079 void FundingLocked_set_next_per_commitment_point(struct LDKFundingLocked *NONNULL_PTR this_ptr, struct LDKPublicKey val);
8080
8081 /**
8082  * Constructs a new FundingLocked given each field
8083  */
8084 MUST_USE_RES struct LDKFundingLocked FundingLocked_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKPublicKey next_per_commitment_point_arg);
8085
8086 /**
8087  * Creates a copy of the FundingLocked
8088  */
8089 struct LDKFundingLocked FundingLocked_clone(const struct LDKFundingLocked *NONNULL_PTR orig);
8090
8091 /**
8092  * Frees any resources used by the Shutdown, if is_owned is set and inner is non-NULL.
8093  */
8094 void Shutdown_free(struct LDKShutdown this_obj);
8095
8096 /**
8097  * The channel ID
8098  */
8099 const uint8_t (*Shutdown_get_channel_id(const struct LDKShutdown *NONNULL_PTR this_ptr))[32];
8100
8101 /**
8102  * The channel ID
8103  */
8104 void Shutdown_set_channel_id(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
8105
8106 /**
8107  * The destination of this peer's funds on closing.
8108  * Must be in one of these forms: p2pkh, p2sh, p2wpkh, p2wsh.
8109  */
8110 struct LDKu8slice Shutdown_get_scriptpubkey(const struct LDKShutdown *NONNULL_PTR this_ptr);
8111
8112 /**
8113  * The destination of this peer's funds on closing.
8114  * Must be in one of these forms: p2pkh, p2sh, p2wpkh, p2wsh.
8115  */
8116 void Shutdown_set_scriptpubkey(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
8117
8118 /**
8119  * Constructs a new Shutdown given each field
8120  */
8121 MUST_USE_RES struct LDKShutdown Shutdown_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKCVec_u8Z scriptpubkey_arg);
8122
8123 /**
8124  * Creates a copy of the Shutdown
8125  */
8126 struct LDKShutdown Shutdown_clone(const struct LDKShutdown *NONNULL_PTR orig);
8127
8128 /**
8129  * Frees any resources used by the ClosingSigned, if is_owned is set and inner is non-NULL.
8130  */
8131 void ClosingSigned_free(struct LDKClosingSigned this_obj);
8132
8133 /**
8134  * The channel ID
8135  */
8136 const uint8_t (*ClosingSigned_get_channel_id(const struct LDKClosingSigned *NONNULL_PTR this_ptr))[32];
8137
8138 /**
8139  * The channel ID
8140  */
8141 void ClosingSigned_set_channel_id(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
8142
8143 /**
8144  * The proposed total fee for the closing transaction
8145  */
8146 uint64_t ClosingSigned_get_fee_satoshis(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
8147
8148 /**
8149  * The proposed total fee for the closing transaction
8150  */
8151 void ClosingSigned_set_fee_satoshis(struct LDKClosingSigned *NONNULL_PTR this_ptr, uint64_t val);
8152
8153 /**
8154  * A signature on the closing transaction
8155  */
8156 struct LDKSignature ClosingSigned_get_signature(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
8157
8158 /**
8159  * A signature on the closing transaction
8160  */
8161 void ClosingSigned_set_signature(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
8162
8163 /**
8164  * Constructs a new ClosingSigned given each field
8165  */
8166 MUST_USE_RES struct LDKClosingSigned ClosingSigned_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t fee_satoshis_arg, struct LDKSignature signature_arg);
8167
8168 /**
8169  * Creates a copy of the ClosingSigned
8170  */
8171 struct LDKClosingSigned ClosingSigned_clone(const struct LDKClosingSigned *NONNULL_PTR orig);
8172
8173 /**
8174  * Frees any resources used by the UpdateAddHTLC, if is_owned is set and inner is non-NULL.
8175  */
8176 void UpdateAddHTLC_free(struct LDKUpdateAddHTLC this_obj);
8177
8178 /**
8179  * The channel ID
8180  */
8181 const uint8_t (*UpdateAddHTLC_get_channel_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
8182
8183 /**
8184  * The channel ID
8185  */
8186 void UpdateAddHTLC_set_channel_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
8187
8188 /**
8189  * The HTLC ID
8190  */
8191 uint64_t UpdateAddHTLC_get_htlc_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
8192
8193 /**
8194  * The HTLC ID
8195  */
8196 void UpdateAddHTLC_set_htlc_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
8197
8198 /**
8199  * The HTLC value in milli-satoshi
8200  */
8201 uint64_t UpdateAddHTLC_get_amount_msat(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
8202
8203 /**
8204  * The HTLC value in milli-satoshi
8205  */
8206 void UpdateAddHTLC_set_amount_msat(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
8207
8208 /**
8209  * The payment hash, the pre-image of which controls HTLC redemption
8210  */
8211 const uint8_t (*UpdateAddHTLC_get_payment_hash(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
8212
8213 /**
8214  * The payment hash, the pre-image of which controls HTLC redemption
8215  */
8216 void UpdateAddHTLC_set_payment_hash(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
8217
8218 /**
8219  * The expiry height of the HTLC
8220  */
8221 uint32_t UpdateAddHTLC_get_cltv_expiry(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
8222
8223 /**
8224  * The expiry height of the HTLC
8225  */
8226 void UpdateAddHTLC_set_cltv_expiry(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint32_t val);
8227
8228 /**
8229  * Creates a copy of the UpdateAddHTLC
8230  */
8231 struct LDKUpdateAddHTLC UpdateAddHTLC_clone(const struct LDKUpdateAddHTLC *NONNULL_PTR orig);
8232
8233 /**
8234  * Frees any resources used by the UpdateFulfillHTLC, if is_owned is set and inner is non-NULL.
8235  */
8236 void UpdateFulfillHTLC_free(struct LDKUpdateFulfillHTLC this_obj);
8237
8238 /**
8239  * The channel ID
8240  */
8241 const uint8_t (*UpdateFulfillHTLC_get_channel_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
8242
8243 /**
8244  * The channel ID
8245  */
8246 void UpdateFulfillHTLC_set_channel_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
8247
8248 /**
8249  * The HTLC ID
8250  */
8251 uint64_t UpdateFulfillHTLC_get_htlc_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr);
8252
8253 /**
8254  * The HTLC ID
8255  */
8256 void UpdateFulfillHTLC_set_htlc_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, uint64_t val);
8257
8258 /**
8259  * The pre-image of the payment hash, allowing HTLC redemption
8260  */
8261 const uint8_t (*UpdateFulfillHTLC_get_payment_preimage(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
8262
8263 /**
8264  * The pre-image of the payment hash, allowing HTLC redemption
8265  */
8266 void UpdateFulfillHTLC_set_payment_preimage(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
8267
8268 /**
8269  * Constructs a new UpdateFulfillHTLC given each field
8270  */
8271 MUST_USE_RES struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t htlc_id_arg, struct LDKThirtyTwoBytes payment_preimage_arg);
8272
8273 /**
8274  * Creates a copy of the UpdateFulfillHTLC
8275  */
8276 struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_clone(const struct LDKUpdateFulfillHTLC *NONNULL_PTR orig);
8277
8278 /**
8279  * Frees any resources used by the UpdateFailHTLC, if is_owned is set and inner is non-NULL.
8280  */
8281 void UpdateFailHTLC_free(struct LDKUpdateFailHTLC this_obj);
8282
8283 /**
8284  * The channel ID
8285  */
8286 const uint8_t (*UpdateFailHTLC_get_channel_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr))[32];
8287
8288 /**
8289  * The channel ID
8290  */
8291 void UpdateFailHTLC_set_channel_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
8292
8293 /**
8294  * The HTLC ID
8295  */
8296 uint64_t UpdateFailHTLC_get_htlc_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr);
8297
8298 /**
8299  * The HTLC ID
8300  */
8301 void UpdateFailHTLC_set_htlc_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, uint64_t val);
8302
8303 /**
8304  * Creates a copy of the UpdateFailHTLC
8305  */
8306 struct LDKUpdateFailHTLC UpdateFailHTLC_clone(const struct LDKUpdateFailHTLC *NONNULL_PTR orig);
8307
8308 /**
8309  * Frees any resources used by the UpdateFailMalformedHTLC, if is_owned is set and inner is non-NULL.
8310  */
8311 void UpdateFailMalformedHTLC_free(struct LDKUpdateFailMalformedHTLC this_obj);
8312
8313 /**
8314  * The channel ID
8315  */
8316 const uint8_t (*UpdateFailMalformedHTLC_get_channel_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr))[32];
8317
8318 /**
8319  * The channel ID
8320  */
8321 void UpdateFailMalformedHTLC_set_channel_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
8322
8323 /**
8324  * The HTLC ID
8325  */
8326 uint64_t UpdateFailMalformedHTLC_get_htlc_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
8327
8328 /**
8329  * The HTLC ID
8330  */
8331 void UpdateFailMalformedHTLC_set_htlc_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint64_t val);
8332
8333 /**
8334  * The failure code
8335  */
8336 uint16_t UpdateFailMalformedHTLC_get_failure_code(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
8337
8338 /**
8339  * The failure code
8340  */
8341 void UpdateFailMalformedHTLC_set_failure_code(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint16_t val);
8342
8343 /**
8344  * Creates a copy of the UpdateFailMalformedHTLC
8345  */
8346 struct LDKUpdateFailMalformedHTLC UpdateFailMalformedHTLC_clone(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR orig);
8347
8348 /**
8349  * Frees any resources used by the CommitmentSigned, if is_owned is set and inner is non-NULL.
8350  */
8351 void CommitmentSigned_free(struct LDKCommitmentSigned this_obj);
8352
8353 /**
8354  * The channel ID
8355  */
8356 const uint8_t (*CommitmentSigned_get_channel_id(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr))[32];
8357
8358 /**
8359  * The channel ID
8360  */
8361 void CommitmentSigned_set_channel_id(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
8362
8363 /**
8364  * A signature on the commitment transaction
8365  */
8366 struct LDKSignature CommitmentSigned_get_signature(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr);
8367
8368 /**
8369  * A signature on the commitment transaction
8370  */
8371 void CommitmentSigned_set_signature(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
8372
8373 /**
8374  * Signatures on the HTLC transactions
8375  */
8376 void CommitmentSigned_set_htlc_signatures(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKCVec_SignatureZ val);
8377
8378 /**
8379  * Constructs a new CommitmentSigned given each field
8380  */
8381 MUST_USE_RES struct LDKCommitmentSigned CommitmentSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKSignature signature_arg, struct LDKCVec_SignatureZ htlc_signatures_arg);
8382
8383 /**
8384  * Creates a copy of the CommitmentSigned
8385  */
8386 struct LDKCommitmentSigned CommitmentSigned_clone(const struct LDKCommitmentSigned *NONNULL_PTR orig);
8387
8388 /**
8389  * Frees any resources used by the RevokeAndACK, if is_owned is set and inner is non-NULL.
8390  */
8391 void RevokeAndACK_free(struct LDKRevokeAndACK this_obj);
8392
8393 /**
8394  * The channel ID
8395  */
8396 const uint8_t (*RevokeAndACK_get_channel_id(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
8397
8398 /**
8399  * The channel ID
8400  */
8401 void RevokeAndACK_set_channel_id(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
8402
8403 /**
8404  * The secret corresponding to the per-commitment point
8405  */
8406 const uint8_t (*RevokeAndACK_get_per_commitment_secret(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
8407
8408 /**
8409  * The secret corresponding to the per-commitment point
8410  */
8411 void RevokeAndACK_set_per_commitment_secret(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
8412
8413 /**
8414  * The next sender-broadcast commitment transaction's per-commitment point
8415  */
8416 struct LDKPublicKey RevokeAndACK_get_next_per_commitment_point(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr);
8417
8418 /**
8419  * The next sender-broadcast commitment transaction's per-commitment point
8420  */
8421 void RevokeAndACK_set_next_per_commitment_point(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKPublicKey val);
8422
8423 /**
8424  * Constructs a new RevokeAndACK given each field
8425  */
8426 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);
8427
8428 /**
8429  * Creates a copy of the RevokeAndACK
8430  */
8431 struct LDKRevokeAndACK RevokeAndACK_clone(const struct LDKRevokeAndACK *NONNULL_PTR orig);
8432
8433 /**
8434  * Frees any resources used by the UpdateFee, if is_owned is set and inner is non-NULL.
8435  */
8436 void UpdateFee_free(struct LDKUpdateFee this_obj);
8437
8438 /**
8439  * The channel ID
8440  */
8441 const uint8_t (*UpdateFee_get_channel_id(const struct LDKUpdateFee *NONNULL_PTR this_ptr))[32];
8442
8443 /**
8444  * The channel ID
8445  */
8446 void UpdateFee_set_channel_id(struct LDKUpdateFee *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
8447
8448 /**
8449  * Fee rate per 1000-weight of the transaction
8450  */
8451 uint32_t UpdateFee_get_feerate_per_kw(const struct LDKUpdateFee *NONNULL_PTR this_ptr);
8452
8453 /**
8454  * Fee rate per 1000-weight of the transaction
8455  */
8456 void UpdateFee_set_feerate_per_kw(struct LDKUpdateFee *NONNULL_PTR this_ptr, uint32_t val);
8457
8458 /**
8459  * Constructs a new UpdateFee given each field
8460  */
8461 MUST_USE_RES struct LDKUpdateFee UpdateFee_new(struct LDKThirtyTwoBytes channel_id_arg, uint32_t feerate_per_kw_arg);
8462
8463 /**
8464  * Creates a copy of the UpdateFee
8465  */
8466 struct LDKUpdateFee UpdateFee_clone(const struct LDKUpdateFee *NONNULL_PTR orig);
8467
8468 /**
8469  * Frees any resources used by the DataLossProtect, if is_owned is set and inner is non-NULL.
8470  */
8471 void DataLossProtect_free(struct LDKDataLossProtect this_obj);
8472
8473 /**
8474  * Proof that the sender knows the per-commitment secret of a specific commitment transaction
8475  * belonging to the recipient
8476  */
8477 const uint8_t (*DataLossProtect_get_your_last_per_commitment_secret(const struct LDKDataLossProtect *NONNULL_PTR this_ptr))[32];
8478
8479 /**
8480  * Proof that the sender knows the per-commitment secret of a specific commitment transaction
8481  * belonging to the recipient
8482  */
8483 void DataLossProtect_set_your_last_per_commitment_secret(struct LDKDataLossProtect *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
8484
8485 /**
8486  * The sender's per-commitment point for their current commitment transaction
8487  */
8488 struct LDKPublicKey DataLossProtect_get_my_current_per_commitment_point(const struct LDKDataLossProtect *NONNULL_PTR this_ptr);
8489
8490 /**
8491  * The sender's per-commitment point for their current commitment transaction
8492  */
8493 void DataLossProtect_set_my_current_per_commitment_point(struct LDKDataLossProtect *NONNULL_PTR this_ptr, struct LDKPublicKey val);
8494
8495 /**
8496  * Constructs a new DataLossProtect given each field
8497  */
8498 MUST_USE_RES struct LDKDataLossProtect DataLossProtect_new(struct LDKThirtyTwoBytes your_last_per_commitment_secret_arg, struct LDKPublicKey my_current_per_commitment_point_arg);
8499
8500 /**
8501  * Creates a copy of the DataLossProtect
8502  */
8503 struct LDKDataLossProtect DataLossProtect_clone(const struct LDKDataLossProtect *NONNULL_PTR orig);
8504
8505 /**
8506  * Frees any resources used by the ChannelReestablish, if is_owned is set and inner is non-NULL.
8507  */
8508 void ChannelReestablish_free(struct LDKChannelReestablish this_obj);
8509
8510 /**
8511  * The channel ID
8512  */
8513 const uint8_t (*ChannelReestablish_get_channel_id(const struct LDKChannelReestablish *NONNULL_PTR this_ptr))[32];
8514
8515 /**
8516  * The channel ID
8517  */
8518 void ChannelReestablish_set_channel_id(struct LDKChannelReestablish *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
8519
8520 /**
8521  * The next commitment number for the sender
8522  */
8523 uint64_t ChannelReestablish_get_next_local_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
8524
8525 /**
8526  * The next commitment number for the sender
8527  */
8528 void ChannelReestablish_set_next_local_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
8529
8530 /**
8531  * The next commitment number for the recipient
8532  */
8533 uint64_t ChannelReestablish_get_next_remote_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
8534
8535 /**
8536  * The next commitment number for the recipient
8537  */
8538 void ChannelReestablish_set_next_remote_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
8539
8540 /**
8541  * Creates a copy of the ChannelReestablish
8542  */
8543 struct LDKChannelReestablish ChannelReestablish_clone(const struct LDKChannelReestablish *NONNULL_PTR orig);
8544
8545 /**
8546  * Frees any resources used by the AnnouncementSignatures, if is_owned is set and inner is non-NULL.
8547  */
8548 void AnnouncementSignatures_free(struct LDKAnnouncementSignatures this_obj);
8549
8550 /**
8551  * The channel ID
8552  */
8553 const uint8_t (*AnnouncementSignatures_get_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr))[32];
8554
8555 /**
8556  * The channel ID
8557  */
8558 void AnnouncementSignatures_set_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
8559
8560 /**
8561  * The short channel ID
8562  */
8563 uint64_t AnnouncementSignatures_get_short_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
8564
8565 /**
8566  * The short channel ID
8567  */
8568 void AnnouncementSignatures_set_short_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, uint64_t val);
8569
8570 /**
8571  * A signature by the node key
8572  */
8573 struct LDKSignature AnnouncementSignatures_get_node_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
8574
8575 /**
8576  * A signature by the node key
8577  */
8578 void AnnouncementSignatures_set_node_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKSignature val);
8579
8580 /**
8581  * A signature by the funding key
8582  */
8583 struct LDKSignature AnnouncementSignatures_get_bitcoin_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
8584
8585 /**
8586  * A signature by the funding key
8587  */
8588 void AnnouncementSignatures_set_bitcoin_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKSignature val);
8589
8590 /**
8591  * Constructs a new AnnouncementSignatures given each field
8592  */
8593 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);
8594
8595 /**
8596  * Creates a copy of the AnnouncementSignatures
8597  */
8598 struct LDKAnnouncementSignatures AnnouncementSignatures_clone(const struct LDKAnnouncementSignatures *NONNULL_PTR orig);
8599
8600 /**
8601  * Frees any resources used by the NetAddress
8602  */
8603 void NetAddress_free(struct LDKNetAddress this_ptr);
8604
8605 /**
8606  * Creates a copy of the NetAddress
8607  */
8608 struct LDKNetAddress NetAddress_clone(const struct LDKNetAddress *NONNULL_PTR orig);
8609
8610 /**
8611  * Serialize the NetAddress object into a byte array which can be read by NetAddress_read
8612  */
8613 struct LDKCVec_u8Z NetAddress_write(const struct LDKNetAddress *NONNULL_PTR obj);
8614
8615 /**
8616  * Read a Result from a byte array, created by Result_write
8617  */
8618 struct LDKCResult_CResult_NetAddressu8ZDecodeErrorZ Result_read(struct LDKu8slice ser);
8619
8620 /**
8621  * Frees any resources used by the UnsignedNodeAnnouncement, if is_owned is set and inner is non-NULL.
8622  */
8623 void UnsignedNodeAnnouncement_free(struct LDKUnsignedNodeAnnouncement this_obj);
8624
8625 /**
8626  * The advertised features
8627  */
8628 struct LDKNodeFeatures UnsignedNodeAnnouncement_get_features(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
8629
8630 /**
8631  * The advertised features
8632  */
8633 void UnsignedNodeAnnouncement_set_features(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
8634
8635 /**
8636  * A strictly monotonic announcement counter, with gaps allowed
8637  */
8638 uint32_t UnsignedNodeAnnouncement_get_timestamp(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
8639
8640 /**
8641  * A strictly monotonic announcement counter, with gaps allowed
8642  */
8643 void UnsignedNodeAnnouncement_set_timestamp(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, uint32_t val);
8644
8645 /**
8646  * The node_id this announcement originated from (don't rebroadcast the node_announcement back
8647  * to this node).
8648  */
8649 struct LDKPublicKey UnsignedNodeAnnouncement_get_node_id(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
8650
8651 /**
8652  * The node_id this announcement originated from (don't rebroadcast the node_announcement back
8653  * to this node).
8654  */
8655 void UnsignedNodeAnnouncement_set_node_id(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
8656
8657 /**
8658  * An RGB color for UI purposes
8659  */
8660 const uint8_t (*UnsignedNodeAnnouncement_get_rgb(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr))[3];
8661
8662 /**
8663  * An RGB color for UI purposes
8664  */
8665 void UnsignedNodeAnnouncement_set_rgb(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
8666
8667 /**
8668  * An alias, for UI purposes.  This should be sanitized before use.  There is no guarantee
8669  * of uniqueness.
8670  */
8671 const uint8_t (*UnsignedNodeAnnouncement_get_alias(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr))[32];
8672
8673 /**
8674  * An alias, for UI purposes.  This should be sanitized before use.  There is no guarantee
8675  * of uniqueness.
8676  */
8677 void UnsignedNodeAnnouncement_set_alias(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
8678
8679 /**
8680  * List of addresses on which this node is reachable
8681  */
8682 void UnsignedNodeAnnouncement_set_addresses(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKCVec_NetAddressZ val);
8683
8684 /**
8685  * Creates a copy of the UnsignedNodeAnnouncement
8686  */
8687 struct LDKUnsignedNodeAnnouncement UnsignedNodeAnnouncement_clone(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR orig);
8688
8689 /**
8690  * Frees any resources used by the NodeAnnouncement, if is_owned is set and inner is non-NULL.
8691  */
8692 void NodeAnnouncement_free(struct LDKNodeAnnouncement this_obj);
8693
8694 /**
8695  * The signature by the node key
8696  */
8697 struct LDKSignature NodeAnnouncement_get_signature(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
8698
8699 /**
8700  * The signature by the node key
8701  */
8702 void NodeAnnouncement_set_signature(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
8703
8704 /**
8705  * The actual content of the announcement
8706  */
8707 struct LDKUnsignedNodeAnnouncement NodeAnnouncement_get_contents(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
8708
8709 /**
8710  * The actual content of the announcement
8711  */
8712 void NodeAnnouncement_set_contents(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedNodeAnnouncement val);
8713
8714 /**
8715  * Constructs a new NodeAnnouncement given each field
8716  */
8717 MUST_USE_RES struct LDKNodeAnnouncement NodeAnnouncement_new(struct LDKSignature signature_arg, struct LDKUnsignedNodeAnnouncement contents_arg);
8718
8719 /**
8720  * Creates a copy of the NodeAnnouncement
8721  */
8722 struct LDKNodeAnnouncement NodeAnnouncement_clone(const struct LDKNodeAnnouncement *NONNULL_PTR orig);
8723
8724 /**
8725  * Frees any resources used by the UnsignedChannelAnnouncement, if is_owned is set and inner is non-NULL.
8726  */
8727 void UnsignedChannelAnnouncement_free(struct LDKUnsignedChannelAnnouncement this_obj);
8728
8729 /**
8730  * The advertised channel features
8731  */
8732 struct LDKChannelFeatures UnsignedChannelAnnouncement_get_features(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
8733
8734 /**
8735  * The advertised channel features
8736  */
8737 void UnsignedChannelAnnouncement_set_features(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
8738
8739 /**
8740  * The genesis hash of the blockchain where the channel is to be opened
8741  */
8742 const uint8_t (*UnsignedChannelAnnouncement_get_chain_hash(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr))[32];
8743
8744 /**
8745  * The genesis hash of the blockchain where the channel is to be opened
8746  */
8747 void UnsignedChannelAnnouncement_set_chain_hash(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
8748
8749 /**
8750  * The short channel ID
8751  */
8752 uint64_t UnsignedChannelAnnouncement_get_short_channel_id(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
8753
8754 /**
8755  * The short channel ID
8756  */
8757 void UnsignedChannelAnnouncement_set_short_channel_id(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, uint64_t val);
8758
8759 /**
8760  * One of the two node_ids which are endpoints of this channel
8761  */
8762 struct LDKPublicKey UnsignedChannelAnnouncement_get_node_id_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
8763
8764 /**
8765  * One of the two node_ids which are endpoints of this channel
8766  */
8767 void UnsignedChannelAnnouncement_set_node_id_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
8768
8769 /**
8770  * The other of the two node_ids which are endpoints of this channel
8771  */
8772 struct LDKPublicKey UnsignedChannelAnnouncement_get_node_id_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
8773
8774 /**
8775  * The other of the two node_ids which are endpoints of this channel
8776  */
8777 void UnsignedChannelAnnouncement_set_node_id_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
8778
8779 /**
8780  * The funding key for the first node
8781  */
8782 struct LDKPublicKey UnsignedChannelAnnouncement_get_bitcoin_key_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
8783
8784 /**
8785  * The funding key for the first node
8786  */
8787 void UnsignedChannelAnnouncement_set_bitcoin_key_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
8788
8789 /**
8790  * The funding key for the second node
8791  */
8792 struct LDKPublicKey UnsignedChannelAnnouncement_get_bitcoin_key_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
8793
8794 /**
8795  * The funding key for the second node
8796  */
8797 void UnsignedChannelAnnouncement_set_bitcoin_key_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
8798
8799 /**
8800  * Creates a copy of the UnsignedChannelAnnouncement
8801  */
8802 struct LDKUnsignedChannelAnnouncement UnsignedChannelAnnouncement_clone(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR orig);
8803
8804 /**
8805  * Frees any resources used by the ChannelAnnouncement, if is_owned is set and inner is non-NULL.
8806  */
8807 void ChannelAnnouncement_free(struct LDKChannelAnnouncement this_obj);
8808
8809 /**
8810  * Authentication of the announcement by the first public node
8811  */
8812 struct LDKSignature ChannelAnnouncement_get_node_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
8813
8814 /**
8815  * Authentication of the announcement by the first public node
8816  */
8817 void ChannelAnnouncement_set_node_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
8818
8819 /**
8820  * Authentication of the announcement by the second public node
8821  */
8822 struct LDKSignature ChannelAnnouncement_get_node_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
8823
8824 /**
8825  * Authentication of the announcement by the second public node
8826  */
8827 void ChannelAnnouncement_set_node_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
8828
8829 /**
8830  * Proof of funding UTXO ownership by the first public node
8831  */
8832 struct LDKSignature ChannelAnnouncement_get_bitcoin_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
8833
8834 /**
8835  * Proof of funding UTXO ownership by the first public node
8836  */
8837 void ChannelAnnouncement_set_bitcoin_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
8838
8839 /**
8840  * Proof of funding UTXO ownership by the second public node
8841  */
8842 struct LDKSignature ChannelAnnouncement_get_bitcoin_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
8843
8844 /**
8845  * Proof of funding UTXO ownership by the second public node
8846  */
8847 void ChannelAnnouncement_set_bitcoin_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
8848
8849 /**
8850  * The actual announcement
8851  */
8852 struct LDKUnsignedChannelAnnouncement ChannelAnnouncement_get_contents(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
8853
8854 /**
8855  * The actual announcement
8856  */
8857 void ChannelAnnouncement_set_contents(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedChannelAnnouncement val);
8858
8859 /**
8860  * Constructs a new ChannelAnnouncement given each field
8861  */
8862 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);
8863
8864 /**
8865  * Creates a copy of the ChannelAnnouncement
8866  */
8867 struct LDKChannelAnnouncement ChannelAnnouncement_clone(const struct LDKChannelAnnouncement *NONNULL_PTR orig);
8868
8869 /**
8870  * Frees any resources used by the UnsignedChannelUpdate, if is_owned is set and inner is non-NULL.
8871  */
8872 void UnsignedChannelUpdate_free(struct LDKUnsignedChannelUpdate this_obj);
8873
8874 /**
8875  * The genesis hash of the blockchain where the channel is to be opened
8876  */
8877 const uint8_t (*UnsignedChannelUpdate_get_chain_hash(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr))[32];
8878
8879 /**
8880  * The genesis hash of the blockchain where the channel is to be opened
8881  */
8882 void UnsignedChannelUpdate_set_chain_hash(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
8883
8884 /**
8885  * The short channel ID
8886  */
8887 uint64_t UnsignedChannelUpdate_get_short_channel_id(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
8888
8889 /**
8890  * The short channel ID
8891  */
8892 void UnsignedChannelUpdate_set_short_channel_id(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
8893
8894 /**
8895  * A strictly monotonic announcement counter, with gaps allowed, specific to this channel
8896  */
8897 uint32_t UnsignedChannelUpdate_get_timestamp(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
8898
8899 /**
8900  * A strictly monotonic announcement counter, with gaps allowed, specific to this channel
8901  */
8902 void UnsignedChannelUpdate_set_timestamp(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
8903
8904 /**
8905  * Channel flags
8906  */
8907 uint8_t UnsignedChannelUpdate_get_flags(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
8908
8909 /**
8910  * Channel flags
8911  */
8912 void UnsignedChannelUpdate_set_flags(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint8_t val);
8913
8914 /**
8915  * The number of blocks such that if:
8916  * `incoming_htlc.cltv_expiry < outgoing_htlc.cltv_expiry + cltv_expiry_delta`
8917  * then we need to fail the HTLC backwards. When forwarding an HTLC, cltv_expiry_delta determines
8918  * the outgoing HTLC's minimum cltv_expiry value -- so, if an incoming HTLC comes in with a
8919  * cltv_expiry of 100000, and the node we're forwarding to has a cltv_expiry_delta value of 10,
8920  * then we'll check that the outgoing HTLC's cltv_expiry value is at least 100010 before
8921  * forwarding. Note that the HTLC sender is the one who originally sets this value when
8922  * constructing the route.
8923  */
8924 uint16_t UnsignedChannelUpdate_get_cltv_expiry_delta(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
8925
8926 /**
8927  * The number of blocks such that if:
8928  * `incoming_htlc.cltv_expiry < outgoing_htlc.cltv_expiry + cltv_expiry_delta`
8929  * then we need to fail the HTLC backwards. When forwarding an HTLC, cltv_expiry_delta determines
8930  * the outgoing HTLC's minimum cltv_expiry value -- so, if an incoming HTLC comes in with a
8931  * cltv_expiry of 100000, and the node we're forwarding to has a cltv_expiry_delta value of 10,
8932  * then we'll check that the outgoing HTLC's cltv_expiry value is at least 100010 before
8933  * forwarding. Note that the HTLC sender is the one who originally sets this value when
8934  * constructing the route.
8935  */
8936 void UnsignedChannelUpdate_set_cltv_expiry_delta(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint16_t val);
8937
8938 /**
8939  * The minimum HTLC size incoming to sender, in milli-satoshi
8940  */
8941 uint64_t UnsignedChannelUpdate_get_htlc_minimum_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
8942
8943 /**
8944  * The minimum HTLC size incoming to sender, in milli-satoshi
8945  */
8946 void UnsignedChannelUpdate_set_htlc_minimum_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
8947
8948 /**
8949  * The base HTLC fee charged by sender, in milli-satoshi
8950  */
8951 uint32_t UnsignedChannelUpdate_get_fee_base_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
8952
8953 /**
8954  * The base HTLC fee charged by sender, in milli-satoshi
8955  */
8956 void UnsignedChannelUpdate_set_fee_base_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
8957
8958 /**
8959  * The amount to fee multiplier, in micro-satoshi
8960  */
8961 uint32_t UnsignedChannelUpdate_get_fee_proportional_millionths(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
8962
8963 /**
8964  * The amount to fee multiplier, in micro-satoshi
8965  */
8966 void UnsignedChannelUpdate_set_fee_proportional_millionths(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
8967
8968 /**
8969  * Creates a copy of the UnsignedChannelUpdate
8970  */
8971 struct LDKUnsignedChannelUpdate UnsignedChannelUpdate_clone(const struct LDKUnsignedChannelUpdate *NONNULL_PTR orig);
8972
8973 /**
8974  * Frees any resources used by the ChannelUpdate, if is_owned is set and inner is non-NULL.
8975  */
8976 void ChannelUpdate_free(struct LDKChannelUpdate this_obj);
8977
8978 /**
8979  * A signature of the channel update
8980  */
8981 struct LDKSignature ChannelUpdate_get_signature(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
8982
8983 /**
8984  * A signature of the channel update
8985  */
8986 void ChannelUpdate_set_signature(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKSignature val);
8987
8988 /**
8989  * The actual channel update
8990  */
8991 struct LDKUnsignedChannelUpdate ChannelUpdate_get_contents(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
8992
8993 /**
8994  * The actual channel update
8995  */
8996 void ChannelUpdate_set_contents(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKUnsignedChannelUpdate val);
8997
8998 /**
8999  * Constructs a new ChannelUpdate given each field
9000  */
9001 MUST_USE_RES struct LDKChannelUpdate ChannelUpdate_new(struct LDKSignature signature_arg, struct LDKUnsignedChannelUpdate contents_arg);
9002
9003 /**
9004  * Creates a copy of the ChannelUpdate
9005  */
9006 struct LDKChannelUpdate ChannelUpdate_clone(const struct LDKChannelUpdate *NONNULL_PTR orig);
9007
9008 /**
9009  * Frees any resources used by the QueryChannelRange, if is_owned is set and inner is non-NULL.
9010  */
9011 void QueryChannelRange_free(struct LDKQueryChannelRange this_obj);
9012
9013 /**
9014  * The genesis hash of the blockchain being queried
9015  */
9016 const uint8_t (*QueryChannelRange_get_chain_hash(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr))[32];
9017
9018 /**
9019  * The genesis hash of the blockchain being queried
9020  */
9021 void QueryChannelRange_set_chain_hash(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
9022
9023 /**
9024  * The height of the first block for the channel UTXOs being queried
9025  */
9026 uint32_t QueryChannelRange_get_first_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
9027
9028 /**
9029  * The height of the first block for the channel UTXOs being queried
9030  */
9031 void QueryChannelRange_set_first_blocknum(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
9032
9033 /**
9034  * The number of blocks to include in the query results
9035  */
9036 uint32_t QueryChannelRange_get_number_of_blocks(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
9037
9038 /**
9039  * The number of blocks to include in the query results
9040  */
9041 void QueryChannelRange_set_number_of_blocks(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
9042
9043 /**
9044  * Constructs a new QueryChannelRange given each field
9045  */
9046 MUST_USE_RES struct LDKQueryChannelRange QueryChannelRange_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_blocknum_arg, uint32_t number_of_blocks_arg);
9047
9048 /**
9049  * Creates a copy of the QueryChannelRange
9050  */
9051 struct LDKQueryChannelRange QueryChannelRange_clone(const struct LDKQueryChannelRange *NONNULL_PTR orig);
9052
9053 /**
9054  * Frees any resources used by the ReplyChannelRange, if is_owned is set and inner is non-NULL.
9055  */
9056 void ReplyChannelRange_free(struct LDKReplyChannelRange this_obj);
9057
9058 /**
9059  * The genesis hash of the blockchain being queried
9060  */
9061 const uint8_t (*ReplyChannelRange_get_chain_hash(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr))[32];
9062
9063 /**
9064  * The genesis hash of the blockchain being queried
9065  */
9066 void ReplyChannelRange_set_chain_hash(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
9067
9068 /**
9069  * The height of the first block in the range of the reply
9070  */
9071 uint32_t ReplyChannelRange_get_first_blocknum(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
9072
9073 /**
9074  * The height of the first block in the range of the reply
9075  */
9076 void ReplyChannelRange_set_first_blocknum(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
9077
9078 /**
9079  * The number of blocks included in the range of the reply
9080  */
9081 uint32_t ReplyChannelRange_get_number_of_blocks(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
9082
9083 /**
9084  * The number of blocks included in the range of the reply
9085  */
9086 void ReplyChannelRange_set_number_of_blocks(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
9087
9088 /**
9089  * True when this is the final reply for a query
9090  */
9091 bool ReplyChannelRange_get_sync_complete(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
9092
9093 /**
9094  * True when this is the final reply for a query
9095  */
9096 void ReplyChannelRange_set_sync_complete(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, bool val);
9097
9098 /**
9099  * The short_channel_ids in the channel range
9100  */
9101 void ReplyChannelRange_set_short_channel_ids(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
9102
9103 /**
9104  * Constructs a new ReplyChannelRange given each field
9105  */
9106 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);
9107
9108 /**
9109  * Creates a copy of the ReplyChannelRange
9110  */
9111 struct LDKReplyChannelRange ReplyChannelRange_clone(const struct LDKReplyChannelRange *NONNULL_PTR orig);
9112
9113 /**
9114  * Frees any resources used by the QueryShortChannelIds, if is_owned is set and inner is non-NULL.
9115  */
9116 void QueryShortChannelIds_free(struct LDKQueryShortChannelIds this_obj);
9117
9118 /**
9119  * The genesis hash of the blockchain being queried
9120  */
9121 const uint8_t (*QueryShortChannelIds_get_chain_hash(const struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr))[32];
9122
9123 /**
9124  * The genesis hash of the blockchain being queried
9125  */
9126 void QueryShortChannelIds_set_chain_hash(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
9127
9128 /**
9129  * The short_channel_ids that are being queried
9130  */
9131 void QueryShortChannelIds_set_short_channel_ids(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
9132
9133 /**
9134  * Constructs a new QueryShortChannelIds given each field
9135  */
9136 MUST_USE_RES struct LDKQueryShortChannelIds QueryShortChannelIds_new(struct LDKThirtyTwoBytes chain_hash_arg, struct LDKCVec_u64Z short_channel_ids_arg);
9137
9138 /**
9139  * Creates a copy of the QueryShortChannelIds
9140  */
9141 struct LDKQueryShortChannelIds QueryShortChannelIds_clone(const struct LDKQueryShortChannelIds *NONNULL_PTR orig);
9142
9143 /**
9144  * Frees any resources used by the ReplyShortChannelIdsEnd, if is_owned is set and inner is non-NULL.
9145  */
9146 void ReplyShortChannelIdsEnd_free(struct LDKReplyShortChannelIdsEnd this_obj);
9147
9148 /**
9149  * The genesis hash of the blockchain that was queried
9150  */
9151 const uint8_t (*ReplyShortChannelIdsEnd_get_chain_hash(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr))[32];
9152
9153 /**
9154  * The genesis hash of the blockchain that was queried
9155  */
9156 void ReplyShortChannelIdsEnd_set_chain_hash(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
9157
9158 /**
9159  * Indicates if the query recipient maintains up-to-date channel
9160  * information for the chain_hash
9161  */
9162 bool ReplyShortChannelIdsEnd_get_full_information(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr);
9163
9164 /**
9165  * Indicates if the query recipient maintains up-to-date channel
9166  * information for the chain_hash
9167  */
9168 void ReplyShortChannelIdsEnd_set_full_information(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, bool val);
9169
9170 /**
9171  * Constructs a new ReplyShortChannelIdsEnd given each field
9172  */
9173 MUST_USE_RES struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_new(struct LDKThirtyTwoBytes chain_hash_arg, bool full_information_arg);
9174
9175 /**
9176  * Creates a copy of the ReplyShortChannelIdsEnd
9177  */
9178 struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_clone(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR orig);
9179
9180 /**
9181  * Frees any resources used by the GossipTimestampFilter, if is_owned is set and inner is non-NULL.
9182  */
9183 void GossipTimestampFilter_free(struct LDKGossipTimestampFilter this_obj);
9184
9185 /**
9186  * The genesis hash of the blockchain for channel and node information
9187  */
9188 const uint8_t (*GossipTimestampFilter_get_chain_hash(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr))[32];
9189
9190 /**
9191  * The genesis hash of the blockchain for channel and node information
9192  */
9193 void GossipTimestampFilter_set_chain_hash(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
9194
9195 /**
9196  * The starting unix timestamp
9197  */
9198 uint32_t GossipTimestampFilter_get_first_timestamp(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
9199
9200 /**
9201  * The starting unix timestamp
9202  */
9203 void GossipTimestampFilter_set_first_timestamp(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
9204
9205 /**
9206  * The range of information in seconds
9207  */
9208 uint32_t GossipTimestampFilter_get_timestamp_range(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
9209
9210 /**
9211  * The range of information in seconds
9212  */
9213 void GossipTimestampFilter_set_timestamp_range(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
9214
9215 /**
9216  * Constructs a new GossipTimestampFilter given each field
9217  */
9218 MUST_USE_RES struct LDKGossipTimestampFilter GossipTimestampFilter_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_timestamp_arg, uint32_t timestamp_range_arg);
9219
9220 /**
9221  * Creates a copy of the GossipTimestampFilter
9222  */
9223 struct LDKGossipTimestampFilter GossipTimestampFilter_clone(const struct LDKGossipTimestampFilter *NONNULL_PTR orig);
9224
9225 /**
9226  * Frees any resources used by the ErrorAction
9227  */
9228 void ErrorAction_free(struct LDKErrorAction this_ptr);
9229
9230 /**
9231  * Creates a copy of the ErrorAction
9232  */
9233 struct LDKErrorAction ErrorAction_clone(const struct LDKErrorAction *NONNULL_PTR orig);
9234
9235 /**
9236  * Frees any resources used by the LightningError, if is_owned is set and inner is non-NULL.
9237  */
9238 void LightningError_free(struct LDKLightningError this_obj);
9239
9240 /**
9241  * A human-readable message describing the error
9242  */
9243 struct LDKStr LightningError_get_err(const struct LDKLightningError *NONNULL_PTR this_ptr);
9244
9245 /**
9246  * A human-readable message describing the error
9247  */
9248 void LightningError_set_err(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
9249
9250 /**
9251  * The action which should be taken against the offending peer.
9252  */
9253 struct LDKErrorAction LightningError_get_action(const struct LDKLightningError *NONNULL_PTR this_ptr);
9254
9255 /**
9256  * The action which should be taken against the offending peer.
9257  */
9258 void LightningError_set_action(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKErrorAction val);
9259
9260 /**
9261  * Constructs a new LightningError given each field
9262  */
9263 MUST_USE_RES struct LDKLightningError LightningError_new(struct LDKCVec_u8Z err_arg, struct LDKErrorAction action_arg);
9264
9265 /**
9266  * Creates a copy of the LightningError
9267  */
9268 struct LDKLightningError LightningError_clone(const struct LDKLightningError *NONNULL_PTR orig);
9269
9270 /**
9271  * Frees any resources used by the CommitmentUpdate, if is_owned is set and inner is non-NULL.
9272  */
9273 void CommitmentUpdate_free(struct LDKCommitmentUpdate this_obj);
9274
9275 /**
9276  * update_add_htlc messages which should be sent
9277  */
9278 void CommitmentUpdate_set_update_add_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateAddHTLCZ val);
9279
9280 /**
9281  * update_fulfill_htlc messages which should be sent
9282  */
9283 void CommitmentUpdate_set_update_fulfill_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFulfillHTLCZ val);
9284
9285 /**
9286  * update_fail_htlc messages which should be sent
9287  */
9288 void CommitmentUpdate_set_update_fail_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailHTLCZ val);
9289
9290 /**
9291  * update_fail_malformed_htlc messages which should be sent
9292  */
9293 void CommitmentUpdate_set_update_fail_malformed_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailMalformedHTLCZ val);
9294
9295 /**
9296  * An update_fee message which should be sent
9297  */
9298 struct LDKUpdateFee CommitmentUpdate_get_update_fee(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
9299
9300 /**
9301  * An update_fee message which should be sent
9302  */
9303 void CommitmentUpdate_set_update_fee(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKUpdateFee val);
9304
9305 /**
9306  * Finally, the commitment_signed message which should be sent
9307  */
9308 struct LDKCommitmentSigned CommitmentUpdate_get_commitment_signed(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
9309
9310 /**
9311  * Finally, the commitment_signed message which should be sent
9312  */
9313 void CommitmentUpdate_set_commitment_signed(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCommitmentSigned val);
9314
9315 /**
9316  * Constructs a new CommitmentUpdate given each field
9317  */
9318 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);
9319
9320 /**
9321  * Creates a copy of the CommitmentUpdate
9322  */
9323 struct LDKCommitmentUpdate CommitmentUpdate_clone(const struct LDKCommitmentUpdate *NONNULL_PTR orig);
9324
9325 /**
9326  * Frees any resources used by the HTLCFailChannelUpdate
9327  */
9328 void HTLCFailChannelUpdate_free(struct LDKHTLCFailChannelUpdate this_ptr);
9329
9330 /**
9331  * Creates a copy of the HTLCFailChannelUpdate
9332  */
9333 struct LDKHTLCFailChannelUpdate HTLCFailChannelUpdate_clone(const struct LDKHTLCFailChannelUpdate *NONNULL_PTR orig);
9334
9335 /**
9336  * Calls the free function if one is set
9337  */
9338 void ChannelMessageHandler_free(struct LDKChannelMessageHandler this_ptr);
9339
9340 /**
9341  * Calls the free function if one is set
9342  */
9343 void RoutingMessageHandler_free(struct LDKRoutingMessageHandler this_ptr);
9344
9345 /**
9346  * Serialize the AcceptChannel object into a byte array which can be read by AcceptChannel_read
9347  */
9348 struct LDKCVec_u8Z AcceptChannel_write(const struct LDKAcceptChannel *NONNULL_PTR obj);
9349
9350 /**
9351  * Read a AcceptChannel from a byte array, created by AcceptChannel_write
9352  */
9353 struct LDKCResult_AcceptChannelDecodeErrorZ AcceptChannel_read(struct LDKu8slice ser);
9354
9355 /**
9356  * Serialize the AnnouncementSignatures object into a byte array which can be read by AnnouncementSignatures_read
9357  */
9358 struct LDKCVec_u8Z AnnouncementSignatures_write(const struct LDKAnnouncementSignatures *NONNULL_PTR obj);
9359
9360 /**
9361  * Read a AnnouncementSignatures from a byte array, created by AnnouncementSignatures_write
9362  */
9363 struct LDKCResult_AnnouncementSignaturesDecodeErrorZ AnnouncementSignatures_read(struct LDKu8slice ser);
9364
9365 /**
9366  * Serialize the ChannelReestablish object into a byte array which can be read by ChannelReestablish_read
9367  */
9368 struct LDKCVec_u8Z ChannelReestablish_write(const struct LDKChannelReestablish *NONNULL_PTR obj);
9369
9370 /**
9371  * Read a ChannelReestablish from a byte array, created by ChannelReestablish_write
9372  */
9373 struct LDKCResult_ChannelReestablishDecodeErrorZ ChannelReestablish_read(struct LDKu8slice ser);
9374
9375 /**
9376  * Serialize the ClosingSigned object into a byte array which can be read by ClosingSigned_read
9377  */
9378 struct LDKCVec_u8Z ClosingSigned_write(const struct LDKClosingSigned *NONNULL_PTR obj);
9379
9380 /**
9381  * Read a ClosingSigned from a byte array, created by ClosingSigned_write
9382  */
9383 struct LDKCResult_ClosingSignedDecodeErrorZ ClosingSigned_read(struct LDKu8slice ser);
9384
9385 /**
9386  * Serialize the CommitmentSigned object into a byte array which can be read by CommitmentSigned_read
9387  */
9388 struct LDKCVec_u8Z CommitmentSigned_write(const struct LDKCommitmentSigned *NONNULL_PTR obj);
9389
9390 /**
9391  * Read a CommitmentSigned from a byte array, created by CommitmentSigned_write
9392  */
9393 struct LDKCResult_CommitmentSignedDecodeErrorZ CommitmentSigned_read(struct LDKu8slice ser);
9394
9395 /**
9396  * Serialize the FundingCreated object into a byte array which can be read by FundingCreated_read
9397  */
9398 struct LDKCVec_u8Z FundingCreated_write(const struct LDKFundingCreated *NONNULL_PTR obj);
9399
9400 /**
9401  * Read a FundingCreated from a byte array, created by FundingCreated_write
9402  */
9403 struct LDKCResult_FundingCreatedDecodeErrorZ FundingCreated_read(struct LDKu8slice ser);
9404
9405 /**
9406  * Serialize the FundingSigned object into a byte array which can be read by FundingSigned_read
9407  */
9408 struct LDKCVec_u8Z FundingSigned_write(const struct LDKFundingSigned *NONNULL_PTR obj);
9409
9410 /**
9411  * Read a FundingSigned from a byte array, created by FundingSigned_write
9412  */
9413 struct LDKCResult_FundingSignedDecodeErrorZ FundingSigned_read(struct LDKu8slice ser);
9414
9415 /**
9416  * Serialize the FundingLocked object into a byte array which can be read by FundingLocked_read
9417  */
9418 struct LDKCVec_u8Z FundingLocked_write(const struct LDKFundingLocked *NONNULL_PTR obj);
9419
9420 /**
9421  * Read a FundingLocked from a byte array, created by FundingLocked_write
9422  */
9423 struct LDKCResult_FundingLockedDecodeErrorZ FundingLocked_read(struct LDKu8slice ser);
9424
9425 /**
9426  * Serialize the Init object into a byte array which can be read by Init_read
9427  */
9428 struct LDKCVec_u8Z Init_write(const struct LDKInit *NONNULL_PTR obj);
9429
9430 /**
9431  * Read a Init from a byte array, created by Init_write
9432  */
9433 struct LDKCResult_InitDecodeErrorZ Init_read(struct LDKu8slice ser);
9434
9435 /**
9436  * Serialize the OpenChannel object into a byte array which can be read by OpenChannel_read
9437  */
9438 struct LDKCVec_u8Z OpenChannel_write(const struct LDKOpenChannel *NONNULL_PTR obj);
9439
9440 /**
9441  * Read a OpenChannel from a byte array, created by OpenChannel_write
9442  */
9443 struct LDKCResult_OpenChannelDecodeErrorZ OpenChannel_read(struct LDKu8slice ser);
9444
9445 /**
9446  * Serialize the RevokeAndACK object into a byte array which can be read by RevokeAndACK_read
9447  */
9448 struct LDKCVec_u8Z RevokeAndACK_write(const struct LDKRevokeAndACK *NONNULL_PTR obj);
9449
9450 /**
9451  * Read a RevokeAndACK from a byte array, created by RevokeAndACK_write
9452  */
9453 struct LDKCResult_RevokeAndACKDecodeErrorZ RevokeAndACK_read(struct LDKu8slice ser);
9454
9455 /**
9456  * Serialize the Shutdown object into a byte array which can be read by Shutdown_read
9457  */
9458 struct LDKCVec_u8Z Shutdown_write(const struct LDKShutdown *NONNULL_PTR obj);
9459
9460 /**
9461  * Read a Shutdown from a byte array, created by Shutdown_write
9462  */
9463 struct LDKCResult_ShutdownDecodeErrorZ Shutdown_read(struct LDKu8slice ser);
9464
9465 /**
9466  * Serialize the UpdateFailHTLC object into a byte array which can be read by UpdateFailHTLC_read
9467  */
9468 struct LDKCVec_u8Z UpdateFailHTLC_write(const struct LDKUpdateFailHTLC *NONNULL_PTR obj);
9469
9470 /**
9471  * Read a UpdateFailHTLC from a byte array, created by UpdateFailHTLC_write
9472  */
9473 struct LDKCResult_UpdateFailHTLCDecodeErrorZ UpdateFailHTLC_read(struct LDKu8slice ser);
9474
9475 /**
9476  * Serialize the UpdateFailMalformedHTLC object into a byte array which can be read by UpdateFailMalformedHTLC_read
9477  */
9478 struct LDKCVec_u8Z UpdateFailMalformedHTLC_write(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR obj);
9479
9480 /**
9481  * Read a UpdateFailMalformedHTLC from a byte array, created by UpdateFailMalformedHTLC_write
9482  */
9483 struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ UpdateFailMalformedHTLC_read(struct LDKu8slice ser);
9484
9485 /**
9486  * Serialize the UpdateFee object into a byte array which can be read by UpdateFee_read
9487  */
9488 struct LDKCVec_u8Z UpdateFee_write(const struct LDKUpdateFee *NONNULL_PTR obj);
9489
9490 /**
9491  * Read a UpdateFee from a byte array, created by UpdateFee_write
9492  */
9493 struct LDKCResult_UpdateFeeDecodeErrorZ UpdateFee_read(struct LDKu8slice ser);
9494
9495 /**
9496  * Serialize the UpdateFulfillHTLC object into a byte array which can be read by UpdateFulfillHTLC_read
9497  */
9498 struct LDKCVec_u8Z UpdateFulfillHTLC_write(const struct LDKUpdateFulfillHTLC *NONNULL_PTR obj);
9499
9500 /**
9501  * Read a UpdateFulfillHTLC from a byte array, created by UpdateFulfillHTLC_write
9502  */
9503 struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ UpdateFulfillHTLC_read(struct LDKu8slice ser);
9504
9505 /**
9506  * Serialize the UpdateAddHTLC object into a byte array which can be read by UpdateAddHTLC_read
9507  */
9508 struct LDKCVec_u8Z UpdateAddHTLC_write(const struct LDKUpdateAddHTLC *NONNULL_PTR obj);
9509
9510 /**
9511  * Read a UpdateAddHTLC from a byte array, created by UpdateAddHTLC_write
9512  */
9513 struct LDKCResult_UpdateAddHTLCDecodeErrorZ UpdateAddHTLC_read(struct LDKu8slice ser);
9514
9515 /**
9516  * Serialize the Ping object into a byte array which can be read by Ping_read
9517  */
9518 struct LDKCVec_u8Z Ping_write(const struct LDKPing *NONNULL_PTR obj);
9519
9520 /**
9521  * Read a Ping from a byte array, created by Ping_write
9522  */
9523 struct LDKCResult_PingDecodeErrorZ Ping_read(struct LDKu8slice ser);
9524
9525 /**
9526  * Serialize the Pong object into a byte array which can be read by Pong_read
9527  */
9528 struct LDKCVec_u8Z Pong_write(const struct LDKPong *NONNULL_PTR obj);
9529
9530 /**
9531  * Read a Pong from a byte array, created by Pong_write
9532  */
9533 struct LDKCResult_PongDecodeErrorZ Pong_read(struct LDKu8slice ser);
9534
9535 /**
9536  * Serialize the UnsignedChannelAnnouncement object into a byte array which can be read by UnsignedChannelAnnouncement_read
9537  */
9538 struct LDKCVec_u8Z UnsignedChannelAnnouncement_write(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR obj);
9539
9540 /**
9541  * Read a UnsignedChannelAnnouncement from a byte array, created by UnsignedChannelAnnouncement_write
9542  */
9543 struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ UnsignedChannelAnnouncement_read(struct LDKu8slice ser);
9544
9545 /**
9546  * Serialize the ChannelAnnouncement object into a byte array which can be read by ChannelAnnouncement_read
9547  */
9548 struct LDKCVec_u8Z ChannelAnnouncement_write(const struct LDKChannelAnnouncement *NONNULL_PTR obj);
9549
9550 /**
9551  * Read a ChannelAnnouncement from a byte array, created by ChannelAnnouncement_write
9552  */
9553 struct LDKCResult_ChannelAnnouncementDecodeErrorZ ChannelAnnouncement_read(struct LDKu8slice ser);
9554
9555 /**
9556  * Serialize the UnsignedChannelUpdate object into a byte array which can be read by UnsignedChannelUpdate_read
9557  */
9558 struct LDKCVec_u8Z UnsignedChannelUpdate_write(const struct LDKUnsignedChannelUpdate *NONNULL_PTR obj);
9559
9560 /**
9561  * Read a UnsignedChannelUpdate from a byte array, created by UnsignedChannelUpdate_write
9562  */
9563 struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ UnsignedChannelUpdate_read(struct LDKu8slice ser);
9564
9565 /**
9566  * Serialize the ChannelUpdate object into a byte array which can be read by ChannelUpdate_read
9567  */
9568 struct LDKCVec_u8Z ChannelUpdate_write(const struct LDKChannelUpdate *NONNULL_PTR obj);
9569
9570 /**
9571  * Read a ChannelUpdate from a byte array, created by ChannelUpdate_write
9572  */
9573 struct LDKCResult_ChannelUpdateDecodeErrorZ ChannelUpdate_read(struct LDKu8slice ser);
9574
9575 /**
9576  * Serialize the ErrorMessage object into a byte array which can be read by ErrorMessage_read
9577  */
9578 struct LDKCVec_u8Z ErrorMessage_write(const struct LDKErrorMessage *NONNULL_PTR obj);
9579
9580 /**
9581  * Read a ErrorMessage from a byte array, created by ErrorMessage_write
9582  */
9583 struct LDKCResult_ErrorMessageDecodeErrorZ ErrorMessage_read(struct LDKu8slice ser);
9584
9585 /**
9586  * Serialize the UnsignedNodeAnnouncement object into a byte array which can be read by UnsignedNodeAnnouncement_read
9587  */
9588 struct LDKCVec_u8Z UnsignedNodeAnnouncement_write(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR obj);
9589
9590 /**
9591  * Read a UnsignedNodeAnnouncement from a byte array, created by UnsignedNodeAnnouncement_write
9592  */
9593 struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ UnsignedNodeAnnouncement_read(struct LDKu8slice ser);
9594
9595 /**
9596  * Serialize the NodeAnnouncement object into a byte array which can be read by NodeAnnouncement_read
9597  */
9598 struct LDKCVec_u8Z NodeAnnouncement_write(const struct LDKNodeAnnouncement *NONNULL_PTR obj);
9599
9600 /**
9601  * Read a NodeAnnouncement from a byte array, created by NodeAnnouncement_write
9602  */
9603 struct LDKCResult_NodeAnnouncementDecodeErrorZ NodeAnnouncement_read(struct LDKu8slice ser);
9604
9605 /**
9606  * Read a QueryShortChannelIds from a byte array, created by QueryShortChannelIds_write
9607  */
9608 struct LDKCResult_QueryShortChannelIdsDecodeErrorZ QueryShortChannelIds_read(struct LDKu8slice ser);
9609
9610 /**
9611  * Serialize the QueryShortChannelIds object into a byte array which can be read by QueryShortChannelIds_read
9612  */
9613 struct LDKCVec_u8Z QueryShortChannelIds_write(const struct LDKQueryShortChannelIds *NONNULL_PTR obj);
9614
9615 /**
9616  * Read a ReplyShortChannelIdsEnd from a byte array, created by ReplyShortChannelIdsEnd_write
9617  */
9618 struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ ReplyShortChannelIdsEnd_read(struct LDKu8slice ser);
9619
9620 /**
9621  * Serialize the ReplyShortChannelIdsEnd object into a byte array which can be read by ReplyShortChannelIdsEnd_read
9622  */
9623 struct LDKCVec_u8Z ReplyShortChannelIdsEnd_write(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR obj);
9624
9625 /**
9626  *\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
9627  */
9628 MUST_USE_RES uint32_t QueryChannelRange_end_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_arg);
9629
9630 /**
9631  * Read a QueryChannelRange from a byte array, created by QueryChannelRange_write
9632  */
9633 struct LDKCResult_QueryChannelRangeDecodeErrorZ QueryChannelRange_read(struct LDKu8slice ser);
9634
9635 /**
9636  * Serialize the QueryChannelRange object into a byte array which can be read by QueryChannelRange_read
9637  */
9638 struct LDKCVec_u8Z QueryChannelRange_write(const struct LDKQueryChannelRange *NONNULL_PTR obj);
9639
9640 /**
9641  * Read a ReplyChannelRange from a byte array, created by ReplyChannelRange_write
9642  */
9643 struct LDKCResult_ReplyChannelRangeDecodeErrorZ ReplyChannelRange_read(struct LDKu8slice ser);
9644
9645 /**
9646  * Serialize the ReplyChannelRange object into a byte array which can be read by ReplyChannelRange_read
9647  */
9648 struct LDKCVec_u8Z ReplyChannelRange_write(const struct LDKReplyChannelRange *NONNULL_PTR obj);
9649
9650 /**
9651  * Read a GossipTimestampFilter from a byte array, created by GossipTimestampFilter_write
9652  */
9653 struct LDKCResult_GossipTimestampFilterDecodeErrorZ GossipTimestampFilter_read(struct LDKu8slice ser);
9654
9655 /**
9656  * Serialize the GossipTimestampFilter object into a byte array which can be read by GossipTimestampFilter_read
9657  */
9658 struct LDKCVec_u8Z GossipTimestampFilter_write(const struct LDKGossipTimestampFilter *NONNULL_PTR obj);
9659
9660 /**
9661  * Frees any resources used by the IgnoringMessageHandler, if is_owned is set and inner is non-NULL.
9662  */
9663 void IgnoringMessageHandler_free(struct LDKIgnoringMessageHandler this_obj);
9664
9665 /**
9666  * Constructs a new IgnoringMessageHandler given each field
9667  */
9668 MUST_USE_RES struct LDKIgnoringMessageHandler IgnoringMessageHandler_new(void);
9669
9670 /**
9671  * Constructs a new MessageSendEventsProvider which calls the relevant methods on this_arg.
9672  * This copies the `inner` pointer in this_arg and thus the returned MessageSendEventsProvider must be freed before this_arg is
9673  */
9674 struct LDKMessageSendEventsProvider IgnoringMessageHandler_as_MessageSendEventsProvider(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
9675
9676 /**
9677  * Constructs a new RoutingMessageHandler which calls the relevant methods on this_arg.
9678  * This copies the `inner` pointer in this_arg and thus the returned RoutingMessageHandler must be freed before this_arg is
9679  */
9680 struct LDKRoutingMessageHandler IgnoringMessageHandler_as_RoutingMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
9681
9682 /**
9683  * Frees any resources used by the ErroringMessageHandler, if is_owned is set and inner is non-NULL.
9684  */
9685 void ErroringMessageHandler_free(struct LDKErroringMessageHandler this_obj);
9686
9687 /**
9688  * Constructs a new ErroringMessageHandler
9689  */
9690 MUST_USE_RES struct LDKErroringMessageHandler ErroringMessageHandler_new(void);
9691
9692 /**
9693  * Constructs a new MessageSendEventsProvider which calls the relevant methods on this_arg.
9694  * This copies the `inner` pointer in this_arg and thus the returned MessageSendEventsProvider must be freed before this_arg is
9695  */
9696 struct LDKMessageSendEventsProvider ErroringMessageHandler_as_MessageSendEventsProvider(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
9697
9698 /**
9699  * Constructs a new ChannelMessageHandler which calls the relevant methods on this_arg.
9700  * This copies the `inner` pointer in this_arg and thus the returned ChannelMessageHandler must be freed before this_arg is
9701  */
9702 struct LDKChannelMessageHandler ErroringMessageHandler_as_ChannelMessageHandler(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
9703
9704 /**
9705  * Frees any resources used by the MessageHandler, if is_owned is set and inner is non-NULL.
9706  */
9707 void MessageHandler_free(struct LDKMessageHandler this_obj);
9708
9709 /**
9710  * A message handler which handles messages specific to channels. Usually this is just a
9711  * ChannelManager object or a ErroringMessageHandler.
9712  */
9713 const struct LDKChannelMessageHandler *MessageHandler_get_chan_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
9714
9715 /**
9716  * A message handler which handles messages specific to channels. Usually this is just a
9717  * ChannelManager object or a ErroringMessageHandler.
9718  */
9719 void MessageHandler_set_chan_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKChannelMessageHandler val);
9720
9721 /**
9722  * A message handler which handles messages updating our knowledge of the network channel
9723  * graph. Usually this is just a NetGraphMsgHandlerMonitor object or an IgnoringMessageHandler.
9724  */
9725 const struct LDKRoutingMessageHandler *MessageHandler_get_route_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
9726
9727 /**
9728  * A message handler which handles messages updating our knowledge of the network channel
9729  * graph. Usually this is just a NetGraphMsgHandlerMonitor object or an IgnoringMessageHandler.
9730  */
9731 void MessageHandler_set_route_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKRoutingMessageHandler val);
9732
9733 /**
9734  * Constructs a new MessageHandler given each field
9735  */
9736 MUST_USE_RES struct LDKMessageHandler MessageHandler_new(struct LDKChannelMessageHandler chan_handler_arg, struct LDKRoutingMessageHandler route_handler_arg);
9737
9738 /**
9739  * Creates a copy of a SocketDescriptor
9740  */
9741 struct LDKSocketDescriptor SocketDescriptor_clone(const struct LDKSocketDescriptor *NONNULL_PTR orig);
9742
9743 /**
9744  * Calls the free function if one is set
9745  */
9746 void SocketDescriptor_free(struct LDKSocketDescriptor this_ptr);
9747
9748 /**
9749  * Frees any resources used by the PeerHandleError, if is_owned is set and inner is non-NULL.
9750  */
9751 void PeerHandleError_free(struct LDKPeerHandleError this_obj);
9752
9753 /**
9754  * Used to indicate that we probably can't make any future connections to this peer, implying
9755  * we should go ahead and force-close any channels we have with it.
9756  */
9757 bool PeerHandleError_get_no_connection_possible(const struct LDKPeerHandleError *NONNULL_PTR this_ptr);
9758
9759 /**
9760  * Used to indicate that we probably can't make any future connections to this peer, implying
9761  * we should go ahead and force-close any channels we have with it.
9762  */
9763 void PeerHandleError_set_no_connection_possible(struct LDKPeerHandleError *NONNULL_PTR this_ptr, bool val);
9764
9765 /**
9766  * Constructs a new PeerHandleError given each field
9767  */
9768 MUST_USE_RES struct LDKPeerHandleError PeerHandleError_new(bool no_connection_possible_arg);
9769
9770 /**
9771  * Creates a copy of the PeerHandleError
9772  */
9773 struct LDKPeerHandleError PeerHandleError_clone(const struct LDKPeerHandleError *NONNULL_PTR orig);
9774
9775 /**
9776  * Frees any resources used by the PeerManager, if is_owned is set and inner is non-NULL.
9777  */
9778 void PeerManager_free(struct LDKPeerManager this_obj);
9779
9780 /**
9781  * Constructs a new PeerManager with the given message handlers and node_id secret key
9782  * ephemeral_random_data is used to derive per-connection ephemeral keys and must be
9783  * cryptographically secure random bytes.
9784  */
9785 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);
9786
9787 /**
9788  * Get the list of node ids for peers which have completed the initial handshake.
9789  *
9790  * For outbound connections, this will be the same as the their_node_id parameter passed in to
9791  * new_outbound_connection, however entries will only appear once the initial handshake has
9792  * completed and we are sure the remote peer has the private key for the given node_id.
9793  */
9794 MUST_USE_RES struct LDKCVec_PublicKeyZ PeerManager_get_peer_node_ids(const struct LDKPeerManager *NONNULL_PTR this_arg);
9795
9796 /**
9797  * Indicates a new outbound connection has been established to a node with the given node_id.
9798  * Note that if an Err is returned here you MUST NOT call socket_disconnected for the new
9799  * descriptor but must disconnect the connection immediately.
9800  *
9801  * Returns a small number of bytes to send to the remote node (currently always 50).
9802  *
9803  * Panics if descriptor is duplicative with some other descriptor which has not yet had a
9804  * socket_disconnected().
9805  */
9806 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);
9807
9808 /**
9809  * Indicates a new inbound connection has been established.
9810  *
9811  * May refuse the connection by returning an Err, but will never write bytes to the remote end
9812  * (outbound connector always speaks first). Note that if an Err is returned here you MUST NOT
9813  * call socket_disconnected for the new descriptor but must disconnect the connection
9814  * immediately.
9815  *
9816  * Panics if descriptor is duplicative with some other descriptor which has not yet had
9817  * socket_disconnected called.
9818  */
9819 MUST_USE_RES struct LDKCResult_NonePeerHandleErrorZ PeerManager_new_inbound_connection(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKSocketDescriptor descriptor);
9820
9821 /**
9822  * Indicates that there is room to write data to the given socket descriptor.
9823  *
9824  * May return an Err to indicate that the connection should be closed.
9825  *
9826  * Will most likely call send_data on the descriptor passed in (or the descriptor handed into
9827  * new_*\\_connection) before returning. Thus, be very careful with reentrancy issues! The
9828  * invariants around calling write_buffer_space_avail in case a write did not fully complete
9829  * must still hold - be ready to call write_buffer_space_avail again if a write call generated
9830  * here isn't sufficient! Panics if the descriptor was not previously registered in a
9831  * new_\\*_connection event.
9832  */
9833 MUST_USE_RES struct LDKCResult_NonePeerHandleErrorZ PeerManager_write_buffer_space_avail(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKSocketDescriptor *NONNULL_PTR descriptor);
9834
9835 /**
9836  * Indicates that data was read from the given socket descriptor.
9837  *
9838  * May return an Err to indicate that the connection should be closed.
9839  *
9840  * Will *not* call back into send_data on any descriptors to avoid reentrancy complexity.
9841  * Thus, however, you almost certainly want to call process_events() after any read_event to
9842  * generate send_data calls to handle responses.
9843  *
9844  * If Ok(true) is returned, further read_events should not be triggered until a send_data call
9845  * on this file descriptor has resume_read set (preventing DoS issues in the send buffer).
9846  *
9847  * Panics if the descriptor was not previously registered in a new_*_connection event.
9848  */
9849 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);
9850
9851 /**
9852  * Checks for any events generated by our handlers and processes them. Includes sending most
9853  * response messages as well as messages generated by calls to handler functions directly (eg
9854  * functions like ChannelManager::process_pending_htlc_forward or send_payment).
9855  */
9856 void PeerManager_process_events(const struct LDKPeerManager *NONNULL_PTR this_arg);
9857
9858 /**
9859  * Indicates that the given socket descriptor's connection is now closed.
9860  *
9861  * This must only be called if the socket has been disconnected by the peer or your own
9862  * decision to disconnect it and must NOT be called in any case where other parts of this
9863  * library (eg PeerHandleError, explicit disconnect_socket calls) instruct you to disconnect
9864  * the peer.
9865  *
9866  * Panics if the descriptor was not previously registered in a successful new_*_connection event.
9867  */
9868 void PeerManager_socket_disconnected(const struct LDKPeerManager *NONNULL_PTR this_arg, const struct LDKSocketDescriptor *NONNULL_PTR descriptor);
9869
9870 /**
9871  * Disconnect a peer given its node id.
9872  *
9873  * Set no_connection_possible to true to prevent any further connection with this peer,
9874  * force-closing any channels we have with it.
9875  *
9876  * If a peer is connected, this will call `disconnect_socket` on the descriptor for the peer,
9877  * so be careful about reentrancy issues.
9878  */
9879 void PeerManager_disconnect_by_node_id(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKPublicKey node_id, bool no_connection_possible);
9880
9881 /**
9882  * This function should be called roughly once every 30 seconds.
9883  * It will send pings to each peer and disconnect those which did not respond to the last round of pings.
9884  * Will most likely call send_data on all of the registered descriptors, thus, be very careful with reentrancy issues!
9885  */
9886 void PeerManager_timer_tick_occurred(const struct LDKPeerManager *NONNULL_PTR this_arg);
9887
9888 /**
9889  * Build the commitment secret from the seed and the commitment number
9890  */
9891 struct LDKThirtyTwoBytes build_commitment_secret(const uint8_t (*commitment_seed)[32], uint64_t idx);
9892
9893 /**
9894  * Derives a per-commitment-transaction private key (eg an htlc key or delayed_payment key)
9895  * from the base secret and the per_commitment_point.
9896  *
9897  * Note that this is infallible iff we trust that at least one of the two input keys are randomly
9898  * generated (ie our own).
9899  */
9900 struct LDKCResult_SecretKeyErrorZ derive_private_key(struct LDKPublicKey per_commitment_point, const uint8_t (*base_secret)[32]);
9901
9902 /**
9903  * Derives a per-commitment-transaction public key (eg an htlc key or a delayed_payment key)
9904  * from the base point and the per_commitment_key. This is the public equivalent of
9905  * derive_private_key - using only public keys to derive a public key instead of private keys.
9906  *
9907  * Note that this is infallible iff we trust that at least one of the two input keys are randomly
9908  * generated (ie our own).
9909  */
9910 struct LDKCResult_PublicKeyErrorZ derive_public_key(struct LDKPublicKey per_commitment_point, struct LDKPublicKey base_point);
9911
9912 /**
9913  * Derives a per-commitment-transaction revocation key from its constituent parts.
9914  *
9915  * Only the cheating participant owns a valid witness to propagate a revoked
9916  * commitment transaction, thus per_commitment_secret always come from cheater
9917  * and revocation_base_secret always come from punisher, which is the broadcaster
9918  * of the transaction spending with this key knowledge.
9919  *
9920  * Note that this is infallible iff we trust that at least one of the two input keys are randomly
9921  * generated (ie our own).
9922  */
9923 struct LDKCResult_SecretKeyErrorZ derive_private_revocation_key(const uint8_t (*per_commitment_secret)[32], const uint8_t (*countersignatory_revocation_base_secret)[32]);
9924
9925 /**
9926  * Derives a per-commitment-transaction revocation public key from its constituent parts. This is
9927  * the public equivalend of derive_private_revocation_key - using only public keys to derive a
9928  * public key instead of private keys.
9929  *
9930  * Only the cheating participant owns a valid witness to propagate a revoked
9931  * commitment transaction, thus per_commitment_point always come from cheater
9932  * and revocation_base_point always come from punisher, which is the broadcaster
9933  * of the transaction spending with this key knowledge.
9934  *
9935  * Note that this is infallible iff we trust that at least one of the two input keys are randomly
9936  * generated (ie our own).
9937  */
9938 struct LDKCResult_PublicKeyErrorZ derive_public_revocation_key(struct LDKPublicKey per_commitment_point, struct LDKPublicKey countersignatory_revocation_base_point);
9939
9940 /**
9941  * Frees any resources used by the TxCreationKeys, if is_owned is set and inner is non-NULL.
9942  */
9943 void TxCreationKeys_free(struct LDKTxCreationKeys this_obj);
9944
9945 /**
9946  * The broadcaster's per-commitment public key which was used to derive the other keys.
9947  */
9948 struct LDKPublicKey TxCreationKeys_get_per_commitment_point(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
9949
9950 /**
9951  * The broadcaster's per-commitment public key which was used to derive the other keys.
9952  */
9953 void TxCreationKeys_set_per_commitment_point(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
9954
9955 /**
9956  * The revocation key which is used to allow the broadcaster of the commitment
9957  * transaction to provide their counterparty the ability to punish them if they broadcast
9958  * an old state.
9959  */
9960 struct LDKPublicKey TxCreationKeys_get_revocation_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
9961
9962 /**
9963  * The revocation key which is used to allow the broadcaster of the commitment
9964  * transaction to provide their counterparty the ability to punish them if they broadcast
9965  * an old state.
9966  */
9967 void TxCreationKeys_set_revocation_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
9968
9969 /**
9970  * Broadcaster's HTLC Key
9971  */
9972 struct LDKPublicKey TxCreationKeys_get_broadcaster_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
9973
9974 /**
9975  * Broadcaster's HTLC Key
9976  */
9977 void TxCreationKeys_set_broadcaster_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
9978
9979 /**
9980  * Countersignatory's HTLC Key
9981  */
9982 struct LDKPublicKey TxCreationKeys_get_countersignatory_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
9983
9984 /**
9985  * Countersignatory's HTLC Key
9986  */
9987 void TxCreationKeys_set_countersignatory_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
9988
9989 /**
9990  * Broadcaster's Payment Key (which isn't allowed to be spent from for some delay)
9991  */
9992 struct LDKPublicKey TxCreationKeys_get_broadcaster_delayed_payment_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
9993
9994 /**
9995  * Broadcaster's Payment Key (which isn't allowed to be spent from for some delay)
9996  */
9997 void TxCreationKeys_set_broadcaster_delayed_payment_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
9998
9999 /**
10000  * Constructs a new TxCreationKeys given each field
10001  */
10002 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);
10003
10004 /**
10005  * Creates a copy of the TxCreationKeys
10006  */
10007 struct LDKTxCreationKeys TxCreationKeys_clone(const struct LDKTxCreationKeys *NONNULL_PTR orig);
10008
10009 /**
10010  * Serialize the TxCreationKeys object into a byte array which can be read by TxCreationKeys_read
10011  */
10012 struct LDKCVec_u8Z TxCreationKeys_write(const struct LDKTxCreationKeys *NONNULL_PTR obj);
10013
10014 /**
10015  * Read a TxCreationKeys from a byte array, created by TxCreationKeys_write
10016  */
10017 struct LDKCResult_TxCreationKeysDecodeErrorZ TxCreationKeys_read(struct LDKu8slice ser);
10018
10019 /**
10020  * Frees any resources used by the ChannelPublicKeys, if is_owned is set and inner is non-NULL.
10021  */
10022 void ChannelPublicKeys_free(struct LDKChannelPublicKeys this_obj);
10023
10024 /**
10025  * The public key which is used to sign all commitment transactions, as it appears in the
10026  * on-chain channel lock-in 2-of-2 multisig output.
10027  */
10028 struct LDKPublicKey ChannelPublicKeys_get_funding_pubkey(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
10029
10030 /**
10031  * The public key which is used to sign all commitment transactions, as it appears in the
10032  * on-chain channel lock-in 2-of-2 multisig output.
10033  */
10034 void ChannelPublicKeys_set_funding_pubkey(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
10035
10036 /**
10037  * The base point which is used (with derive_public_revocation_key) to derive per-commitment
10038  * revocation keys. This is combined with the per-commitment-secret generated by the
10039  * counterparty to create a secret which the counterparty can reveal to revoke previous
10040  * states.
10041  */
10042 struct LDKPublicKey ChannelPublicKeys_get_revocation_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
10043
10044 /**
10045  * The base point which is used (with derive_public_revocation_key) to derive per-commitment
10046  * revocation keys. This is combined with the per-commitment-secret generated by the
10047  * counterparty to create a secret which the counterparty can reveal to revoke previous
10048  * states.
10049  */
10050 void ChannelPublicKeys_set_revocation_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
10051
10052 /**
10053  * The public key on which the non-broadcaster (ie the countersignatory) receives an immediately
10054  * spendable primary channel balance on the broadcaster's commitment transaction. This key is
10055  * static across every commitment transaction.
10056  */
10057 struct LDKPublicKey ChannelPublicKeys_get_payment_point(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
10058
10059 /**
10060  * The public key on which the non-broadcaster (ie the countersignatory) receives an immediately
10061  * spendable primary channel balance on the broadcaster's commitment transaction. This key is
10062  * static across every commitment transaction.
10063  */
10064 void ChannelPublicKeys_set_payment_point(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
10065
10066 /**
10067  * The base point which is used (with derive_public_key) to derive a per-commitment payment
10068  * public key which receives non-HTLC-encumbered funds which are only available for spending
10069  * after some delay (or can be claimed via the revocation path).
10070  */
10071 struct LDKPublicKey ChannelPublicKeys_get_delayed_payment_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
10072
10073 /**
10074  * The base point which is used (with derive_public_key) to derive a per-commitment payment
10075  * public key which receives non-HTLC-encumbered funds which are only available for spending
10076  * after some delay (or can be claimed via the revocation path).
10077  */
10078 void ChannelPublicKeys_set_delayed_payment_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
10079
10080 /**
10081  * The base point which is used (with derive_public_key) to derive a per-commitment public key
10082  * which is used to encumber HTLC-in-flight outputs.
10083  */
10084 struct LDKPublicKey ChannelPublicKeys_get_htlc_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
10085
10086 /**
10087  * The base point which is used (with derive_public_key) to derive a per-commitment public key
10088  * which is used to encumber HTLC-in-flight outputs.
10089  */
10090 void ChannelPublicKeys_set_htlc_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
10091
10092 /**
10093  * Constructs a new ChannelPublicKeys given each field
10094  */
10095 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);
10096
10097 /**
10098  * Creates a copy of the ChannelPublicKeys
10099  */
10100 struct LDKChannelPublicKeys ChannelPublicKeys_clone(const struct LDKChannelPublicKeys *NONNULL_PTR orig);
10101
10102 /**
10103  * Serialize the ChannelPublicKeys object into a byte array which can be read by ChannelPublicKeys_read
10104  */
10105 struct LDKCVec_u8Z ChannelPublicKeys_write(const struct LDKChannelPublicKeys *NONNULL_PTR obj);
10106
10107 /**
10108  * Read a ChannelPublicKeys from a byte array, created by ChannelPublicKeys_write
10109  */
10110 struct LDKCResult_ChannelPublicKeysDecodeErrorZ ChannelPublicKeys_read(struct LDKu8slice ser);
10111
10112 /**
10113  * Create per-state keys from channel base points and the per-commitment point.
10114  * Key set is asymmetric and can't be used as part of counter-signatory set of transactions.
10115  */
10116 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);
10117
10118 /**
10119  * Generate per-state keys from channel static keys.
10120  * Key set is asymmetric and can't be used as part of counter-signatory set of transactions.
10121  */
10122 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);
10123
10124 /**
10125  * A script either spendable by the revocation
10126  * key or the broadcaster_delayed_payment_key and satisfying the relative-locktime OP_CSV constrain.
10127  * Encumbering a `to_holder` output on a commitment transaction or 2nd-stage HTLC transactions.
10128  */
10129 struct LDKCVec_u8Z get_revokeable_redeemscript(struct LDKPublicKey revocation_key, uint16_t contest_delay, struct LDKPublicKey broadcaster_delayed_payment_key);
10130
10131 /**
10132  * Frees any resources used by the HTLCOutputInCommitment, if is_owned is set and inner is non-NULL.
10133  */
10134 void HTLCOutputInCommitment_free(struct LDKHTLCOutputInCommitment this_obj);
10135
10136 /**
10137  * Whether the HTLC was \"offered\" (ie outbound in relation to this commitment transaction).
10138  * Note that this is not the same as whether it is ountbound *from us*. To determine that you
10139  * need to compare this value to whether the commitment transaction in question is that of
10140  * the counterparty or our own.
10141  */
10142 bool HTLCOutputInCommitment_get_offered(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
10143
10144 /**
10145  * Whether the HTLC was \"offered\" (ie outbound in relation to this commitment transaction).
10146  * Note that this is not the same as whether it is ountbound *from us*. To determine that you
10147  * need to compare this value to whether the commitment transaction in question is that of
10148  * the counterparty or our own.
10149  */
10150 void HTLCOutputInCommitment_set_offered(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, bool val);
10151
10152 /**
10153  * The value, in msat, of the HTLC. The value as it appears in the commitment transaction is
10154  * this divided by 1000.
10155  */
10156 uint64_t HTLCOutputInCommitment_get_amount_msat(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
10157
10158 /**
10159  * The value, in msat, of the HTLC. The value as it appears in the commitment transaction is
10160  * this divided by 1000.
10161  */
10162 void HTLCOutputInCommitment_set_amount_msat(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint64_t val);
10163
10164 /**
10165  * The CLTV lock-time at which this HTLC expires.
10166  */
10167 uint32_t HTLCOutputInCommitment_get_cltv_expiry(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
10168
10169 /**
10170  * The CLTV lock-time at which this HTLC expires.
10171  */
10172 void HTLCOutputInCommitment_set_cltv_expiry(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint32_t val);
10173
10174 /**
10175  * The hash of the preimage which unlocks this HTLC.
10176  */
10177 const uint8_t (*HTLCOutputInCommitment_get_payment_hash(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr))[32];
10178
10179 /**
10180  * The hash of the preimage which unlocks this HTLC.
10181  */
10182 void HTLCOutputInCommitment_set_payment_hash(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
10183
10184 /**
10185  * Creates a copy of the HTLCOutputInCommitment
10186  */
10187 struct LDKHTLCOutputInCommitment HTLCOutputInCommitment_clone(const struct LDKHTLCOutputInCommitment *NONNULL_PTR orig);
10188
10189 /**
10190  * Serialize the HTLCOutputInCommitment object into a byte array which can be read by HTLCOutputInCommitment_read
10191  */
10192 struct LDKCVec_u8Z HTLCOutputInCommitment_write(const struct LDKHTLCOutputInCommitment *NONNULL_PTR obj);
10193
10194 /**
10195  * Read a HTLCOutputInCommitment from a byte array, created by HTLCOutputInCommitment_write
10196  */
10197 struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ HTLCOutputInCommitment_read(struct LDKu8slice ser);
10198
10199 /**
10200  * Gets the witness redeemscript for an HTLC output in a commitment transaction. Note that htlc
10201  * does not need to have its previous_output_index filled.
10202  */
10203 struct LDKCVec_u8Z get_htlc_redeemscript(const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc, const struct LDKTxCreationKeys *NONNULL_PTR keys);
10204
10205 /**
10206  * Gets the redeemscript for a funding output from the two funding public keys.
10207  * Note that the order of funding public keys does not matter.
10208  */
10209 struct LDKCVec_u8Z make_funding_redeemscript(struct LDKPublicKey broadcaster, struct LDKPublicKey countersignatory);
10210
10211 /**
10212  * panics if htlc.transaction_output_index.is_none()!
10213  */
10214 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);
10215
10216 /**
10217  * Frees any resources used by the ChannelTransactionParameters, if is_owned is set and inner is non-NULL.
10218  */
10219 void ChannelTransactionParameters_free(struct LDKChannelTransactionParameters this_obj);
10220
10221 /**
10222  * Holder public keys
10223  */
10224 struct LDKChannelPublicKeys ChannelTransactionParameters_get_holder_pubkeys(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
10225
10226 /**
10227  * Holder public keys
10228  */
10229 void ChannelTransactionParameters_set_holder_pubkeys(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
10230
10231 /**
10232  * The contest delay selected by the holder, which applies to counterparty-broadcast transactions
10233  */
10234 uint16_t ChannelTransactionParameters_get_holder_selected_contest_delay(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
10235
10236 /**
10237  * The contest delay selected by the holder, which applies to counterparty-broadcast transactions
10238  */
10239 void ChannelTransactionParameters_set_holder_selected_contest_delay(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
10240
10241 /**
10242  * Whether the holder is the initiator of this channel.
10243  * This is an input to the commitment number obscure factor computation.
10244  */
10245 bool ChannelTransactionParameters_get_is_outbound_from_holder(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
10246
10247 /**
10248  * Whether the holder is the initiator of this channel.
10249  * This is an input to the commitment number obscure factor computation.
10250  */
10251 void ChannelTransactionParameters_set_is_outbound_from_holder(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, bool val);
10252
10253 /**
10254  * The late-bound counterparty channel transaction parameters.
10255  * These parameters are populated at the point in the protocol where the counterparty provides them.
10256  */
10257 struct LDKCounterpartyChannelTransactionParameters ChannelTransactionParameters_get_counterparty_parameters(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
10258
10259 /**
10260  * The late-bound counterparty channel transaction parameters.
10261  * These parameters are populated at the point in the protocol where the counterparty provides them.
10262  */
10263 void ChannelTransactionParameters_set_counterparty_parameters(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKCounterpartyChannelTransactionParameters val);
10264
10265 /**
10266  * The late-bound funding outpoint
10267  */
10268 struct LDKOutPoint ChannelTransactionParameters_get_funding_outpoint(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
10269
10270 /**
10271  * The late-bound funding outpoint
10272  */
10273 void ChannelTransactionParameters_set_funding_outpoint(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKOutPoint val);
10274
10275 /**
10276  * Constructs a new ChannelTransactionParameters given each field
10277  */
10278 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);
10279
10280 /**
10281  * Creates a copy of the ChannelTransactionParameters
10282  */
10283 struct LDKChannelTransactionParameters ChannelTransactionParameters_clone(const struct LDKChannelTransactionParameters *NONNULL_PTR orig);
10284
10285 /**
10286  * Frees any resources used by the CounterpartyChannelTransactionParameters, if is_owned is set and inner is non-NULL.
10287  */
10288 void CounterpartyChannelTransactionParameters_free(struct LDKCounterpartyChannelTransactionParameters this_obj);
10289
10290 /**
10291  * Counter-party public keys
10292  */
10293 struct LDKChannelPublicKeys CounterpartyChannelTransactionParameters_get_pubkeys(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
10294
10295 /**
10296  * Counter-party public keys
10297  */
10298 void CounterpartyChannelTransactionParameters_set_pubkeys(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
10299
10300 /**
10301  * The contest delay selected by the counterparty, which applies to holder-broadcast transactions
10302  */
10303 uint16_t CounterpartyChannelTransactionParameters_get_selected_contest_delay(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
10304
10305 /**
10306  * The contest delay selected by the counterparty, which applies to holder-broadcast transactions
10307  */
10308 void CounterpartyChannelTransactionParameters_set_selected_contest_delay(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
10309
10310 /**
10311  * Constructs a new CounterpartyChannelTransactionParameters given each field
10312  */
10313 MUST_USE_RES struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_new(struct LDKChannelPublicKeys pubkeys_arg, uint16_t selected_contest_delay_arg);
10314
10315 /**
10316  * Creates a copy of the CounterpartyChannelTransactionParameters
10317  */
10318 struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_clone(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR orig);
10319
10320 /**
10321  * Whether the late bound parameters are populated.
10322  */
10323 MUST_USE_RES bool ChannelTransactionParameters_is_populated(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
10324
10325 /**
10326  * Convert the holder/counterparty parameters to broadcaster/countersignatory-organized parameters,
10327  * given that the holder is the broadcaster.
10328  *
10329  * self.is_populated() must be true before calling this function.
10330  */
10331 MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_holder_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
10332
10333 /**
10334  * Convert the holder/counterparty parameters to broadcaster/countersignatory-organized parameters,
10335  * given that the counterparty is the broadcaster.
10336  *
10337  * self.is_populated() must be true before calling this function.
10338  */
10339 MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_counterparty_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
10340
10341 /**
10342  * Serialize the CounterpartyChannelTransactionParameters object into a byte array which can be read by CounterpartyChannelTransactionParameters_read
10343  */
10344 struct LDKCVec_u8Z CounterpartyChannelTransactionParameters_write(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR obj);
10345
10346 /**
10347  * Read a CounterpartyChannelTransactionParameters from a byte array, created by CounterpartyChannelTransactionParameters_write
10348  */
10349 struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CounterpartyChannelTransactionParameters_read(struct LDKu8slice ser);
10350
10351 /**
10352  * Serialize the ChannelTransactionParameters object into a byte array which can be read by ChannelTransactionParameters_read
10353  */
10354 struct LDKCVec_u8Z ChannelTransactionParameters_write(const struct LDKChannelTransactionParameters *NONNULL_PTR obj);
10355
10356 /**
10357  * Read a ChannelTransactionParameters from a byte array, created by ChannelTransactionParameters_write
10358  */
10359 struct LDKCResult_ChannelTransactionParametersDecodeErrorZ ChannelTransactionParameters_read(struct LDKu8slice ser);
10360
10361 /**
10362  * Frees any resources used by the DirectedChannelTransactionParameters, if is_owned is set and inner is non-NULL.
10363  */
10364 void DirectedChannelTransactionParameters_free(struct LDKDirectedChannelTransactionParameters this_obj);
10365
10366 /**
10367  * Get the channel pubkeys for the broadcaster
10368  */
10369 MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_broadcaster_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
10370
10371 /**
10372  * Get the channel pubkeys for the countersignatory
10373  */
10374 MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_countersignatory_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
10375
10376 /**
10377  * Get the contest delay applicable to the transactions.
10378  * Note that the contest delay was selected by the countersignatory.
10379  */
10380 MUST_USE_RES uint16_t DirectedChannelTransactionParameters_contest_delay(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
10381
10382 /**
10383  * Whether the channel is outbound from the broadcaster.
10384  *
10385  * The boolean representing the side that initiated the channel is
10386  * an input to the commitment number obscure factor computation.
10387  */
10388 MUST_USE_RES bool DirectedChannelTransactionParameters_is_outbound(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
10389
10390 /**
10391  * The funding outpoint
10392  */
10393 MUST_USE_RES struct LDKOutPoint DirectedChannelTransactionParameters_funding_outpoint(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
10394
10395 /**
10396  * Frees any resources used by the HolderCommitmentTransaction, if is_owned is set and inner is non-NULL.
10397  */
10398 void HolderCommitmentTransaction_free(struct LDKHolderCommitmentTransaction this_obj);
10399
10400 /**
10401  * Our counterparty's signature for the transaction
10402  */
10403 struct LDKSignature HolderCommitmentTransaction_get_counterparty_sig(const struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr);
10404
10405 /**
10406  * Our counterparty's signature for the transaction
10407  */
10408 void HolderCommitmentTransaction_set_counterparty_sig(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKSignature val);
10409
10410 /**
10411  * All non-dust counterparty HTLC signatures, in the order they appear in the transaction
10412  */
10413 void HolderCommitmentTransaction_set_counterparty_htlc_sigs(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKCVec_SignatureZ val);
10414
10415 /**
10416  * Creates a copy of the HolderCommitmentTransaction
10417  */
10418 struct LDKHolderCommitmentTransaction HolderCommitmentTransaction_clone(const struct LDKHolderCommitmentTransaction *NONNULL_PTR orig);
10419
10420 /**
10421  * Serialize the HolderCommitmentTransaction object into a byte array which can be read by HolderCommitmentTransaction_read
10422  */
10423 struct LDKCVec_u8Z HolderCommitmentTransaction_write(const struct LDKHolderCommitmentTransaction *NONNULL_PTR obj);
10424
10425 /**
10426  * Read a HolderCommitmentTransaction from a byte array, created by HolderCommitmentTransaction_write
10427  */
10428 struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ HolderCommitmentTransaction_read(struct LDKu8slice ser);
10429
10430 /**
10431  * Create a new holder transaction with the given counterparty signatures.
10432  * The funding keys are used to figure out which signature should go first when building the transaction for broadcast.
10433  */
10434 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);
10435
10436 /**
10437  * Frees any resources used by the BuiltCommitmentTransaction, if is_owned is set and inner is non-NULL.
10438  */
10439 void BuiltCommitmentTransaction_free(struct LDKBuiltCommitmentTransaction this_obj);
10440
10441 /**
10442  * The commitment transaction
10443  */
10444 struct LDKTransaction BuiltCommitmentTransaction_get_transaction(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr);
10445
10446 /**
10447  * The commitment transaction
10448  */
10449 void BuiltCommitmentTransaction_set_transaction(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKTransaction val);
10450
10451 /**
10452  * The txid for the commitment transaction.
10453  *
10454  * This is provided as a performance optimization, instead of calling transaction.txid()
10455  * multiple times.
10456  */
10457 const uint8_t (*BuiltCommitmentTransaction_get_txid(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr))[32];
10458
10459 /**
10460  * The txid for the commitment transaction.
10461  *
10462  * This is provided as a performance optimization, instead of calling transaction.txid()
10463  * multiple times.
10464  */
10465 void BuiltCommitmentTransaction_set_txid(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
10466
10467 /**
10468  * Constructs a new BuiltCommitmentTransaction given each field
10469  */
10470 MUST_USE_RES struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_new(struct LDKTransaction transaction_arg, struct LDKThirtyTwoBytes txid_arg);
10471
10472 /**
10473  * Creates a copy of the BuiltCommitmentTransaction
10474  */
10475 struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_clone(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR orig);
10476
10477 /**
10478  * Serialize the BuiltCommitmentTransaction object into a byte array which can be read by BuiltCommitmentTransaction_read
10479  */
10480 struct LDKCVec_u8Z BuiltCommitmentTransaction_write(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR obj);
10481
10482 /**
10483  * Read a BuiltCommitmentTransaction from a byte array, created by BuiltCommitmentTransaction_write
10484  */
10485 struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ BuiltCommitmentTransaction_read(struct LDKu8slice ser);
10486
10487 /**
10488  * Get the SIGHASH_ALL sighash value of the transaction.
10489  *
10490  * This can be used to verify a signature.
10491  */
10492 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);
10493
10494 /**
10495  * Sign a transaction, either because we are counter-signing the counterparty's transaction or
10496  * because we are about to broadcast a holder transaction.
10497  */
10498 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);
10499
10500 /**
10501  * Frees any resources used by the CommitmentTransaction, if is_owned is set and inner is non-NULL.
10502  */
10503 void CommitmentTransaction_free(struct LDKCommitmentTransaction this_obj);
10504
10505 /**
10506  * Creates a copy of the CommitmentTransaction
10507  */
10508 struct LDKCommitmentTransaction CommitmentTransaction_clone(const struct LDKCommitmentTransaction *NONNULL_PTR orig);
10509
10510 /**
10511  * Serialize the CommitmentTransaction object into a byte array which can be read by CommitmentTransaction_read
10512  */
10513 struct LDKCVec_u8Z CommitmentTransaction_write(const struct LDKCommitmentTransaction *NONNULL_PTR obj);
10514
10515 /**
10516  * Read a CommitmentTransaction from a byte array, created by CommitmentTransaction_write
10517  */
10518 struct LDKCResult_CommitmentTransactionDecodeErrorZ CommitmentTransaction_read(struct LDKu8slice ser);
10519
10520 /**
10521  * The backwards-counting commitment number
10522  */
10523 MUST_USE_RES uint64_t CommitmentTransaction_commitment_number(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
10524
10525 /**
10526  * The value to be sent to the broadcaster
10527  */
10528 MUST_USE_RES uint64_t CommitmentTransaction_to_broadcaster_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
10529
10530 /**
10531  * The value to be sent to the counterparty
10532  */
10533 MUST_USE_RES uint64_t CommitmentTransaction_to_countersignatory_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
10534
10535 /**
10536  * The feerate paid per 1000-weight-unit in this commitment transaction.
10537  */
10538 MUST_USE_RES uint32_t CommitmentTransaction_feerate_per_kw(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
10539
10540 /**
10541  * Trust our pre-built transaction and derived transaction creation public keys.
10542  *
10543  * Applies a wrapper which allows access to these fields.
10544  *
10545  * This should only be used if you fully trust the builder of this object.  It should not
10546  *\tbe used by an external signer - instead use the verify function.
10547  */
10548 MUST_USE_RES struct LDKTrustedCommitmentTransaction CommitmentTransaction_trust(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
10549
10550 /**
10551  * Verify our pre-built transaction and derived transaction creation public keys.
10552  *
10553  * Applies a wrapper which allows access to these fields.
10554  *
10555  * An external validating signer must call this method before signing
10556  * or using the built transaction.
10557  */
10558 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);
10559
10560 /**
10561  * Frees any resources used by the TrustedCommitmentTransaction, if is_owned is set and inner is non-NULL.
10562  */
10563 void TrustedCommitmentTransaction_free(struct LDKTrustedCommitmentTransaction this_obj);
10564
10565 /**
10566  * The transaction ID of the built Bitcoin transaction
10567  */
10568 MUST_USE_RES struct LDKThirtyTwoBytes TrustedCommitmentTransaction_txid(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
10569
10570 /**
10571  * The pre-built Bitcoin commitment transaction
10572  */
10573 MUST_USE_RES struct LDKBuiltCommitmentTransaction TrustedCommitmentTransaction_built_transaction(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
10574
10575 /**
10576  * The pre-calculated transaction creation public keys.
10577  */
10578 MUST_USE_RES struct LDKTxCreationKeys TrustedCommitmentTransaction_keys(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
10579
10580 /**
10581  * Get a signature for each HTLC which was included in the commitment transaction (ie for
10582  * which HTLCOutputInCommitment::transaction_output_index.is_some()).
10583  *
10584  * The returned Vec has one entry for each HTLC, and in the same order.
10585  */
10586 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);
10587
10588 /**
10589  * Get the transaction number obscure factor
10590  */
10591 uint64_t get_commitment_transaction_number_obscure_factor(struct LDKPublicKey broadcaster_payment_basepoint, struct LDKPublicKey countersignatory_payment_basepoint, bool outbound_from_broadcaster);
10592
10593 /**
10594  * Creates a copy of the InitFeatures
10595  */
10596 struct LDKInitFeatures InitFeatures_clone(const struct LDKInitFeatures *NONNULL_PTR orig);
10597
10598 /**
10599  * Creates a copy of the NodeFeatures
10600  */
10601 struct LDKNodeFeatures NodeFeatures_clone(const struct LDKNodeFeatures *NONNULL_PTR orig);
10602
10603 /**
10604  * Creates a copy of the ChannelFeatures
10605  */
10606 struct LDKChannelFeatures ChannelFeatures_clone(const struct LDKChannelFeatures *NONNULL_PTR orig);
10607
10608 /**
10609  * Creates a copy of the InvoiceFeatures
10610  */
10611 struct LDKInvoiceFeatures InvoiceFeatures_clone(const struct LDKInvoiceFeatures *NONNULL_PTR orig);
10612
10613 /**
10614  * Frees any resources used by the InitFeatures, if is_owned is set and inner is non-NULL.
10615  */
10616 void InitFeatures_free(struct LDKInitFeatures this_obj);
10617
10618 /**
10619  * Frees any resources used by the NodeFeatures, if is_owned is set and inner is non-NULL.
10620  */
10621 void NodeFeatures_free(struct LDKNodeFeatures this_obj);
10622
10623 /**
10624  * Frees any resources used by the ChannelFeatures, if is_owned is set and inner is non-NULL.
10625  */
10626 void ChannelFeatures_free(struct LDKChannelFeatures this_obj);
10627
10628 /**
10629  * Frees any resources used by the InvoiceFeatures, if is_owned is set and inner is non-NULL.
10630  */
10631 void InvoiceFeatures_free(struct LDKInvoiceFeatures this_obj);
10632
10633 /**
10634  * Create a blank Features with no features set
10635  */
10636 MUST_USE_RES struct LDKInitFeatures InitFeatures_empty(void);
10637
10638 /**
10639  * Creates a Features with the bits set which are known by the implementation
10640  */
10641 MUST_USE_RES struct LDKInitFeatures InitFeatures_known(void);
10642
10643 /**
10644  * Create a blank Features with no features set
10645  */
10646 MUST_USE_RES struct LDKNodeFeatures NodeFeatures_empty(void);
10647
10648 /**
10649  * Creates a Features with the bits set which are known by the implementation
10650  */
10651 MUST_USE_RES struct LDKNodeFeatures NodeFeatures_known(void);
10652
10653 /**
10654  * Create a blank Features with no features set
10655  */
10656 MUST_USE_RES struct LDKChannelFeatures ChannelFeatures_empty(void);
10657
10658 /**
10659  * Creates a Features with the bits set which are known by the implementation
10660  */
10661 MUST_USE_RES struct LDKChannelFeatures ChannelFeatures_known(void);
10662
10663 /**
10664  * Create a blank Features with no features set
10665  */
10666 MUST_USE_RES struct LDKInvoiceFeatures InvoiceFeatures_empty(void);
10667
10668 /**
10669  * Creates a Features with the bits set which are known by the implementation
10670  */
10671 MUST_USE_RES struct LDKInvoiceFeatures InvoiceFeatures_known(void);
10672
10673 /**
10674  * Serialize the InitFeatures object into a byte array which can be read by InitFeatures_read
10675  */
10676 struct LDKCVec_u8Z InitFeatures_write(const struct LDKInitFeatures *NONNULL_PTR obj);
10677
10678 /**
10679  * Serialize the NodeFeatures object into a byte array which can be read by NodeFeatures_read
10680  */
10681 struct LDKCVec_u8Z NodeFeatures_write(const struct LDKNodeFeatures *NONNULL_PTR obj);
10682
10683 /**
10684  * Serialize the ChannelFeatures object into a byte array which can be read by ChannelFeatures_read
10685  */
10686 struct LDKCVec_u8Z ChannelFeatures_write(const struct LDKChannelFeatures *NONNULL_PTR obj);
10687
10688 /**
10689  * Serialize the InvoiceFeatures object into a byte array which can be read by InvoiceFeatures_read
10690  */
10691 struct LDKCVec_u8Z InvoiceFeatures_write(const struct LDKInvoiceFeatures *NONNULL_PTR obj);
10692
10693 /**
10694  * Read a InitFeatures from a byte array, created by InitFeatures_write
10695  */
10696 struct LDKCResult_InitFeaturesDecodeErrorZ InitFeatures_read(struct LDKu8slice ser);
10697
10698 /**
10699  * Read a NodeFeatures from a byte array, created by NodeFeatures_write
10700  */
10701 struct LDKCResult_NodeFeaturesDecodeErrorZ NodeFeatures_read(struct LDKu8slice ser);
10702
10703 /**
10704  * Read a ChannelFeatures from a byte array, created by ChannelFeatures_write
10705  */
10706 struct LDKCResult_ChannelFeaturesDecodeErrorZ ChannelFeatures_read(struct LDKu8slice ser);
10707
10708 /**
10709  * Read a InvoiceFeatures from a byte array, created by InvoiceFeatures_write
10710  */
10711 struct LDKCResult_InvoiceFeaturesDecodeErrorZ InvoiceFeatures_read(struct LDKu8slice ser);
10712
10713 /**
10714  * Frees any resources used by the RouteHop, if is_owned is set and inner is non-NULL.
10715  */
10716 void RouteHop_free(struct LDKRouteHop this_obj);
10717
10718 /**
10719  * The node_id of the node at this hop.
10720  */
10721 struct LDKPublicKey RouteHop_get_pubkey(const struct LDKRouteHop *NONNULL_PTR this_ptr);
10722
10723 /**
10724  * The node_id of the node at this hop.
10725  */
10726 void RouteHop_set_pubkey(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
10727
10728 /**
10729  * The node_announcement features of the node at this hop. For the last hop, these may be
10730  * amended to match the features present in the invoice this node generated.
10731  */
10732 struct LDKNodeFeatures RouteHop_get_node_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
10733
10734 /**
10735  * The node_announcement features of the node at this hop. For the last hop, these may be
10736  * amended to match the features present in the invoice this node generated.
10737  */
10738 void RouteHop_set_node_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
10739
10740 /**
10741  * The channel that should be used from the previous hop to reach this node.
10742  */
10743 uint64_t RouteHop_get_short_channel_id(const struct LDKRouteHop *NONNULL_PTR this_ptr);
10744
10745 /**
10746  * The channel that should be used from the previous hop to reach this node.
10747  */
10748 void RouteHop_set_short_channel_id(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
10749
10750 /**
10751  * The channel_announcement features of the channel that should be used from the previous hop
10752  * to reach this node.
10753  */
10754 struct LDKChannelFeatures RouteHop_get_channel_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
10755
10756 /**
10757  * The channel_announcement features of the channel that should be used from the previous hop
10758  * to reach this node.
10759  */
10760 void RouteHop_set_channel_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
10761
10762 /**
10763  * The fee taken on this hop (for paying for the use of the *next* channel in the path).
10764  * For the last hop, this should be the full value of the payment (might be more than
10765  * requested if we had to match htlc_minimum_msat).
10766  */
10767 uint64_t RouteHop_get_fee_msat(const struct LDKRouteHop *NONNULL_PTR this_ptr);
10768
10769 /**
10770  * The fee taken on this hop (for paying for the use of the *next* channel in the path).
10771  * For the last hop, this should be the full value of the payment (might be more than
10772  * requested if we had to match htlc_minimum_msat).
10773  */
10774 void RouteHop_set_fee_msat(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
10775
10776 /**
10777  * The CLTV delta added for this hop. For the last hop, this should be the full CLTV value
10778  * expected at the destination, in excess of the current block height.
10779  */
10780 uint32_t RouteHop_get_cltv_expiry_delta(const struct LDKRouteHop *NONNULL_PTR this_ptr);
10781
10782 /**
10783  * The CLTV delta added for this hop. For the last hop, this should be the full CLTV value
10784  * expected at the destination, in excess of the current block height.
10785  */
10786 void RouteHop_set_cltv_expiry_delta(struct LDKRouteHop *NONNULL_PTR this_ptr, uint32_t val);
10787
10788 /**
10789  * Constructs a new RouteHop given each field
10790  */
10791 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);
10792
10793 /**
10794  * Creates a copy of the RouteHop
10795  */
10796 struct LDKRouteHop RouteHop_clone(const struct LDKRouteHop *NONNULL_PTR orig);
10797
10798 /**
10799  * Frees any resources used by the Route, if is_owned is set and inner is non-NULL.
10800  */
10801 void Route_free(struct LDKRoute this_obj);
10802
10803 /**
10804  * The list of routes taken for a single (potentially-)multi-part payment. The pubkey of the
10805  * last RouteHop in each path must be the same.
10806  * Each entry represents a list of hops, NOT INCLUDING our own, where the last hop is the
10807  * destination. Thus, this must always be at least length one. While the maximum length of any
10808  * given path is variable, keeping the length of any path to less than 20 should currently
10809  * ensure it is viable.
10810  */
10811 void Route_set_paths(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKCVec_CVec_RouteHopZZ val);
10812
10813 /**
10814  * Constructs a new Route given each field
10815  */
10816 MUST_USE_RES struct LDKRoute Route_new(struct LDKCVec_CVec_RouteHopZZ paths_arg);
10817
10818 /**
10819  * Creates a copy of the Route
10820  */
10821 struct LDKRoute Route_clone(const struct LDKRoute *NONNULL_PTR orig);
10822
10823 /**
10824  * Serialize the Route object into a byte array which can be read by Route_read
10825  */
10826 struct LDKCVec_u8Z Route_write(const struct LDKRoute *NONNULL_PTR obj);
10827
10828 /**
10829  * Read a Route from a byte array, created by Route_write
10830  */
10831 struct LDKCResult_RouteDecodeErrorZ Route_read(struct LDKu8slice ser);
10832
10833 /**
10834  * Frees any resources used by the RouteHint, if is_owned is set and inner is non-NULL.
10835  */
10836 void RouteHint_free(struct LDKRouteHint this_obj);
10837
10838 /**
10839  * The node_id of the non-target end of the route
10840  */
10841 struct LDKPublicKey RouteHint_get_src_node_id(const struct LDKRouteHint *NONNULL_PTR this_ptr);
10842
10843 /**
10844  * The node_id of the non-target end of the route
10845  */
10846 void RouteHint_set_src_node_id(struct LDKRouteHint *NONNULL_PTR this_ptr, struct LDKPublicKey val);
10847
10848 /**
10849  * The short_channel_id of this channel
10850  */
10851 uint64_t RouteHint_get_short_channel_id(const struct LDKRouteHint *NONNULL_PTR this_ptr);
10852
10853 /**
10854  * The short_channel_id of this channel
10855  */
10856 void RouteHint_set_short_channel_id(struct LDKRouteHint *NONNULL_PTR this_ptr, uint64_t val);
10857
10858 /**
10859  * The fees which must be paid to use this channel
10860  */
10861 struct LDKRoutingFees RouteHint_get_fees(const struct LDKRouteHint *NONNULL_PTR this_ptr);
10862
10863 /**
10864  * The fees which must be paid to use this channel
10865  */
10866 void RouteHint_set_fees(struct LDKRouteHint *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
10867
10868 /**
10869  * The difference in CLTV values between this node and the next node.
10870  */
10871 uint16_t RouteHint_get_cltv_expiry_delta(const struct LDKRouteHint *NONNULL_PTR this_ptr);
10872
10873 /**
10874  * The difference in CLTV values between this node and the next node.
10875  */
10876 void RouteHint_set_cltv_expiry_delta(struct LDKRouteHint *NONNULL_PTR this_ptr, uint16_t val);
10877
10878 /**
10879  * Creates a copy of the RouteHint
10880  */
10881 struct LDKRouteHint RouteHint_clone(const struct LDKRouteHint *NONNULL_PTR orig);
10882
10883 /**
10884  * Gets a route from us (payer) to the given target node (payee).
10885  *
10886  * If the payee provided features in their invoice, they should be provided via payee_features.
10887  * Without this, MPP will only be used if the payee's features are available in the network graph.
10888  *
10889  * Extra routing hops between known nodes and the target will be used if they are included in
10890  * last_hops.
10891  *
10892  * If some channels aren't announced, it may be useful to fill in a first_hops with the
10893  * results from a local ChannelManager::list_usable_channels() call. If it is filled in, our
10894  * view of our local channels (from net_graph_msg_handler) will be ignored, and only those
10895  * in first_hops will be used.
10896  *
10897  * Panics if first_hops contains channels without short_channel_ids
10898  * (ChannelManager::list_usable_channels will never include such channels).
10899  *
10900  * The fees on channels from us to next-hops are ignored (as they are assumed to all be
10901  * equal), however the enabled/disabled bit on such channels as well as the
10902  * htlc_minimum_msat/htlc_maximum_msat *are* checked as they may change based on the receiving node.
10903  */
10904 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);
10905
10906 /**
10907  * Frees any resources used by the NetworkGraph, if is_owned is set and inner is non-NULL.
10908  */
10909 void NetworkGraph_free(struct LDKNetworkGraph this_obj);
10910
10911 /**
10912  * Creates a copy of the NetworkGraph
10913  */
10914 struct LDKNetworkGraph NetworkGraph_clone(const struct LDKNetworkGraph *NONNULL_PTR orig);
10915
10916 /**
10917  * Frees any resources used by the LockedNetworkGraph, if is_owned is set and inner is non-NULL.
10918  */
10919 void LockedNetworkGraph_free(struct LDKLockedNetworkGraph this_obj);
10920
10921 /**
10922  * Frees any resources used by the NetGraphMsgHandler, if is_owned is set and inner is non-NULL.
10923  */
10924 void NetGraphMsgHandler_free(struct LDKNetGraphMsgHandler this_obj);
10925
10926 /**
10927  * Creates a new tracker of the actual state of the network of channels and nodes,
10928  * assuming a fresh network graph.
10929  * Chain monitor is used to make sure announced channels exist on-chain,
10930  * channel data is correct, and that the announcement is signed with
10931  * channel owners' keys.
10932  */
10933 MUST_USE_RES struct LDKNetGraphMsgHandler NetGraphMsgHandler_new(struct LDKThirtyTwoBytes genesis_hash, struct LDKAccess *chain_access, struct LDKLogger logger);
10934
10935 /**
10936  * Creates a new tracker of the actual state of the network of channels and nodes,
10937  * assuming an existing Network Graph.
10938  */
10939 MUST_USE_RES struct LDKNetGraphMsgHandler NetGraphMsgHandler_from_net_graph(struct LDKAccess *chain_access, struct LDKLogger logger, struct LDKNetworkGraph network_graph);
10940
10941 /**
10942  * Adds a provider used to check new announcements. Does not affect
10943  * existing announcements unless they are updated.
10944  * Add, update or remove the provider would replace the current one.
10945  */
10946 void NetGraphMsgHandler_add_chain_access(struct LDKNetGraphMsgHandler *NONNULL_PTR this_arg, struct LDKAccess *chain_access);
10947
10948 /**
10949  * Take a read lock on the network_graph and return it in the C-bindings
10950  * newtype helper. This is likely only useful when called via the C
10951  * bindings as you can call `self.network_graph.read().unwrap()` in Rust
10952  * yourself.
10953  */
10954 MUST_USE_RES struct LDKLockedNetworkGraph NetGraphMsgHandler_read_locked_graph(const struct LDKNetGraphMsgHandler *NONNULL_PTR this_arg);
10955
10956 /**
10957  * Get a reference to the NetworkGraph which this read-lock contains.
10958  */
10959 MUST_USE_RES struct LDKNetworkGraph LockedNetworkGraph_graph(const struct LDKLockedNetworkGraph *NONNULL_PTR this_arg);
10960
10961 /**
10962  * Constructs a new RoutingMessageHandler which calls the relevant methods on this_arg.
10963  * This copies the `inner` pointer in this_arg and thus the returned RoutingMessageHandler must be freed before this_arg is
10964  */
10965 struct LDKRoutingMessageHandler NetGraphMsgHandler_as_RoutingMessageHandler(const struct LDKNetGraphMsgHandler *NONNULL_PTR this_arg);
10966
10967 /**
10968  * Constructs a new MessageSendEventsProvider which calls the relevant methods on this_arg.
10969  * This copies the `inner` pointer in this_arg and thus the returned MessageSendEventsProvider must be freed before this_arg is
10970  */
10971 struct LDKMessageSendEventsProvider NetGraphMsgHandler_as_MessageSendEventsProvider(const struct LDKNetGraphMsgHandler *NONNULL_PTR this_arg);
10972
10973 /**
10974  * Frees any resources used by the DirectionalChannelInfo, if is_owned is set and inner is non-NULL.
10975  */
10976 void DirectionalChannelInfo_free(struct LDKDirectionalChannelInfo this_obj);
10977
10978 /**
10979  * When the last update to the channel direction was issued.
10980  * Value is opaque, as set in the announcement.
10981  */
10982 uint32_t DirectionalChannelInfo_get_last_update(const struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr);
10983
10984 /**
10985  * When the last update to the channel direction was issued.
10986  * Value is opaque, as set in the announcement.
10987  */
10988 void DirectionalChannelInfo_set_last_update(struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr, uint32_t val);
10989
10990 /**
10991  * Whether the channel can be currently used for payments (in this one direction).
10992  */
10993 bool DirectionalChannelInfo_get_enabled(const struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr);
10994
10995 /**
10996  * Whether the channel can be currently used for payments (in this one direction).
10997  */
10998 void DirectionalChannelInfo_set_enabled(struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr, bool val);
10999
11000 /**
11001  * The difference in CLTV values that you must have when routing through this channel.
11002  */
11003 uint16_t DirectionalChannelInfo_get_cltv_expiry_delta(const struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr);
11004
11005 /**
11006  * The difference in CLTV values that you must have when routing through this channel.
11007  */
11008 void DirectionalChannelInfo_set_cltv_expiry_delta(struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr, uint16_t val);
11009
11010 /**
11011  * The minimum value, which must be relayed to the next hop via the channel
11012  */
11013 uint64_t DirectionalChannelInfo_get_htlc_minimum_msat(const struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr);
11014
11015 /**
11016  * The minimum value, which must be relayed to the next hop via the channel
11017  */
11018 void DirectionalChannelInfo_set_htlc_minimum_msat(struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr, uint64_t val);
11019
11020 /**
11021  * Fees charged when the channel is used for routing
11022  */
11023 struct LDKRoutingFees DirectionalChannelInfo_get_fees(const struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr);
11024
11025 /**
11026  * Fees charged when the channel is used for routing
11027  */
11028 void DirectionalChannelInfo_set_fees(struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
11029
11030 /**
11031  * Most recent update for the channel received from the network
11032  * Mostly redundant with the data we store in fields explicitly.
11033  * Everything else is useful only for sending out for initial routing sync.
11034  * Not stored if contains excess data to prevent DoS.
11035  */
11036 struct LDKChannelUpdate DirectionalChannelInfo_get_last_update_message(const struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr);
11037
11038 /**
11039  * Most recent update for the channel received from the network
11040  * Mostly redundant with the data we store in fields explicitly.
11041  * Everything else is useful only for sending out for initial routing sync.
11042  * Not stored if contains excess data to prevent DoS.
11043  */
11044 void DirectionalChannelInfo_set_last_update_message(struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdate val);
11045
11046 /**
11047  * Creates a copy of the DirectionalChannelInfo
11048  */
11049 struct LDKDirectionalChannelInfo DirectionalChannelInfo_clone(const struct LDKDirectionalChannelInfo *NONNULL_PTR orig);
11050
11051 /**
11052  * Serialize the DirectionalChannelInfo object into a byte array which can be read by DirectionalChannelInfo_read
11053  */
11054 struct LDKCVec_u8Z DirectionalChannelInfo_write(const struct LDKDirectionalChannelInfo *NONNULL_PTR obj);
11055
11056 /**
11057  * Read a DirectionalChannelInfo from a byte array, created by DirectionalChannelInfo_write
11058  */
11059 struct LDKCResult_DirectionalChannelInfoDecodeErrorZ DirectionalChannelInfo_read(struct LDKu8slice ser);
11060
11061 /**
11062  * Frees any resources used by the ChannelInfo, if is_owned is set and inner is non-NULL.
11063  */
11064 void ChannelInfo_free(struct LDKChannelInfo this_obj);
11065
11066 /**
11067  * Protocol features of a channel communicated during its announcement
11068  */
11069 struct LDKChannelFeatures ChannelInfo_get_features(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
11070
11071 /**
11072  * Protocol features of a channel communicated during its announcement
11073  */
11074 void ChannelInfo_set_features(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
11075
11076 /**
11077  * Source node of the first direction of a channel
11078  */
11079 struct LDKPublicKey ChannelInfo_get_node_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
11080
11081 /**
11082  * Source node of the first direction of a channel
11083  */
11084 void ChannelInfo_set_node_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKPublicKey val);
11085
11086 /**
11087  * Details about the first direction of a channel
11088  */
11089 struct LDKDirectionalChannelInfo ChannelInfo_get_one_to_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
11090
11091 /**
11092  * Details about the first direction of a channel
11093  */
11094 void ChannelInfo_set_one_to_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKDirectionalChannelInfo val);
11095
11096 /**
11097  * Source node of the second direction of a channel
11098  */
11099 struct LDKPublicKey ChannelInfo_get_node_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
11100
11101 /**
11102  * Source node of the second direction of a channel
11103  */
11104 void ChannelInfo_set_node_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKPublicKey val);
11105
11106 /**
11107  * Details about the second direction of a channel
11108  */
11109 struct LDKDirectionalChannelInfo ChannelInfo_get_two_to_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
11110
11111 /**
11112  * Details about the second direction of a channel
11113  */
11114 void ChannelInfo_set_two_to_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKDirectionalChannelInfo val);
11115
11116 /**
11117  * An initial announcement of the channel
11118  * Mostly redundant with the data we store in fields explicitly.
11119  * Everything else is useful only for sending out for initial routing sync.
11120  * Not stored if contains excess data to prevent DoS.
11121  */
11122 struct LDKChannelAnnouncement ChannelInfo_get_announcement_message(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
11123
11124 /**
11125  * An initial announcement of the channel
11126  * Mostly redundant with the data we store in fields explicitly.
11127  * Everything else is useful only for sending out for initial routing sync.
11128  * Not stored if contains excess data to prevent DoS.
11129  */
11130 void ChannelInfo_set_announcement_message(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelAnnouncement val);
11131
11132 /**
11133  * Creates a copy of the ChannelInfo
11134  */
11135 struct LDKChannelInfo ChannelInfo_clone(const struct LDKChannelInfo *NONNULL_PTR orig);
11136
11137 /**
11138  * Serialize the ChannelInfo object into a byte array which can be read by ChannelInfo_read
11139  */
11140 struct LDKCVec_u8Z ChannelInfo_write(const struct LDKChannelInfo *NONNULL_PTR obj);
11141
11142 /**
11143  * Read a ChannelInfo from a byte array, created by ChannelInfo_write
11144  */
11145 struct LDKCResult_ChannelInfoDecodeErrorZ ChannelInfo_read(struct LDKu8slice ser);
11146
11147 /**
11148  * Frees any resources used by the RoutingFees, if is_owned is set and inner is non-NULL.
11149  */
11150 void RoutingFees_free(struct LDKRoutingFees this_obj);
11151
11152 /**
11153  * Flat routing fee in satoshis
11154  */
11155 uint32_t RoutingFees_get_base_msat(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
11156
11157 /**
11158  * Flat routing fee in satoshis
11159  */
11160 void RoutingFees_set_base_msat(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
11161
11162 /**
11163  * Liquidity-based routing fee in millionths of a routed amount.
11164  * In other words, 10000 is 1%.
11165  */
11166 uint32_t RoutingFees_get_proportional_millionths(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
11167
11168 /**
11169  * Liquidity-based routing fee in millionths of a routed amount.
11170  * In other words, 10000 is 1%.
11171  */
11172 void RoutingFees_set_proportional_millionths(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
11173
11174 /**
11175  * Constructs a new RoutingFees given each field
11176  */
11177 MUST_USE_RES struct LDKRoutingFees RoutingFees_new(uint32_t base_msat_arg, uint32_t proportional_millionths_arg);
11178
11179 /**
11180  * Creates a copy of the RoutingFees
11181  */
11182 struct LDKRoutingFees RoutingFees_clone(const struct LDKRoutingFees *NONNULL_PTR orig);
11183
11184 /**
11185  * Read a RoutingFees from a byte array, created by RoutingFees_write
11186  */
11187 struct LDKCResult_RoutingFeesDecodeErrorZ RoutingFees_read(struct LDKu8slice ser);
11188
11189 /**
11190  * Serialize the RoutingFees object into a byte array which can be read by RoutingFees_read
11191  */
11192 struct LDKCVec_u8Z RoutingFees_write(const struct LDKRoutingFees *NONNULL_PTR obj);
11193
11194 /**
11195  * Frees any resources used by the NodeAnnouncementInfo, if is_owned is set and inner is non-NULL.
11196  */
11197 void NodeAnnouncementInfo_free(struct LDKNodeAnnouncementInfo this_obj);
11198
11199 /**
11200  * Protocol features the node announced support for
11201  */
11202 struct LDKNodeFeatures NodeAnnouncementInfo_get_features(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
11203
11204 /**
11205  * Protocol features the node announced support for
11206  */
11207 void NodeAnnouncementInfo_set_features(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
11208
11209 /**
11210  * When the last known update to the node state was issued.
11211  * Value is opaque, as set in the announcement.
11212  */
11213 uint32_t NodeAnnouncementInfo_get_last_update(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
11214
11215 /**
11216  * When the last known update to the node state was issued.
11217  * Value is opaque, as set in the announcement.
11218  */
11219 void NodeAnnouncementInfo_set_last_update(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, uint32_t val);
11220
11221 /**
11222  * Color assigned to the node
11223  */
11224 const uint8_t (*NodeAnnouncementInfo_get_rgb(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr))[3];
11225
11226 /**
11227  * Color assigned to the node
11228  */
11229 void NodeAnnouncementInfo_set_rgb(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
11230
11231 /**
11232  * Moniker assigned to the node.
11233  * May be invalid or malicious (eg control chars),
11234  * should not be exposed to the user.
11235  */
11236 const uint8_t (*NodeAnnouncementInfo_get_alias(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr))[32];
11237
11238 /**
11239  * Moniker assigned to the node.
11240  * May be invalid or malicious (eg control chars),
11241  * should not be exposed to the user.
11242  */
11243 void NodeAnnouncementInfo_set_alias(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
11244
11245 /**
11246  * Internet-level addresses via which one can connect to the node
11247  */
11248 void NodeAnnouncementInfo_set_addresses(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKCVec_NetAddressZ val);
11249
11250 /**
11251  * An initial announcement of the node
11252  * Mostly redundant with the data we store in fields explicitly.
11253  * Everything else is useful only for sending out for initial routing sync.
11254  * Not stored if contains excess data to prevent DoS.
11255  */
11256 struct LDKNodeAnnouncement NodeAnnouncementInfo_get_announcement_message(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
11257
11258 /**
11259  * An initial announcement of the node
11260  * Mostly redundant with the data we store in fields explicitly.
11261  * Everything else is useful only for sending out for initial routing sync.
11262  * Not stored if contains excess data to prevent DoS.
11263  */
11264 void NodeAnnouncementInfo_set_announcement_message(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncement val);
11265
11266 /**
11267  * Constructs a new NodeAnnouncementInfo given each field
11268  */
11269 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);
11270
11271 /**
11272  * Creates a copy of the NodeAnnouncementInfo
11273  */
11274 struct LDKNodeAnnouncementInfo NodeAnnouncementInfo_clone(const struct LDKNodeAnnouncementInfo *NONNULL_PTR orig);
11275
11276 /**
11277  * Serialize the NodeAnnouncementInfo object into a byte array which can be read by NodeAnnouncementInfo_read
11278  */
11279 struct LDKCVec_u8Z NodeAnnouncementInfo_write(const struct LDKNodeAnnouncementInfo *NONNULL_PTR obj);
11280
11281 /**
11282  * Read a NodeAnnouncementInfo from a byte array, created by NodeAnnouncementInfo_write
11283  */
11284 struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ NodeAnnouncementInfo_read(struct LDKu8slice ser);
11285
11286 /**
11287  * Frees any resources used by the NodeInfo, if is_owned is set and inner is non-NULL.
11288  */
11289 void NodeInfo_free(struct LDKNodeInfo this_obj);
11290
11291 /**
11292  * All valid channels a node has announced
11293  */
11294 void NodeInfo_set_channels(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
11295
11296 /**
11297  * Lowest fees enabling routing via any of the enabled, known channels to a node.
11298  * The two fields (flat and proportional fee) are independent,
11299  * meaning they don't have to refer to the same channel.
11300  */
11301 struct LDKRoutingFees NodeInfo_get_lowest_inbound_channel_fees(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
11302
11303 /**
11304  * Lowest fees enabling routing via any of the enabled, known channels to a node.
11305  * The two fields (flat and proportional fee) are independent,
11306  * meaning they don't have to refer to the same channel.
11307  */
11308 void NodeInfo_set_lowest_inbound_channel_fees(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
11309
11310 /**
11311  * More information about a node from node_announcement.
11312  * Optional because we store a Node entry after learning about it from
11313  * a channel announcement, but before receiving a node announcement.
11314  */
11315 struct LDKNodeAnnouncementInfo NodeInfo_get_announcement_info(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
11316
11317 /**
11318  * More information about a node from node_announcement.
11319  * Optional because we store a Node entry after learning about it from
11320  * a channel announcement, but before receiving a node announcement.
11321  */
11322 void NodeInfo_set_announcement_info(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncementInfo val);
11323
11324 /**
11325  * Constructs a new NodeInfo given each field
11326  */
11327 MUST_USE_RES struct LDKNodeInfo NodeInfo_new(struct LDKCVec_u64Z channels_arg, struct LDKRoutingFees lowest_inbound_channel_fees_arg, struct LDKNodeAnnouncementInfo announcement_info_arg);
11328
11329 /**
11330  * Creates a copy of the NodeInfo
11331  */
11332 struct LDKNodeInfo NodeInfo_clone(const struct LDKNodeInfo *NONNULL_PTR orig);
11333
11334 /**
11335  * Serialize the NodeInfo object into a byte array which can be read by NodeInfo_read
11336  */
11337 struct LDKCVec_u8Z NodeInfo_write(const struct LDKNodeInfo *NONNULL_PTR obj);
11338
11339 /**
11340  * Read a NodeInfo from a byte array, created by NodeInfo_write
11341  */
11342 struct LDKCResult_NodeInfoDecodeErrorZ NodeInfo_read(struct LDKu8slice ser);
11343
11344 /**
11345  * Serialize the NetworkGraph object into a byte array which can be read by NetworkGraph_read
11346  */
11347 struct LDKCVec_u8Z NetworkGraph_write(const struct LDKNetworkGraph *NONNULL_PTR obj);
11348
11349 /**
11350  * Read a NetworkGraph from a byte array, created by NetworkGraph_write
11351  */
11352 struct LDKCResult_NetworkGraphDecodeErrorZ NetworkGraph_read(struct LDKu8slice ser);
11353
11354 /**
11355  * Creates a new, empty, network graph.
11356  */
11357 MUST_USE_RES struct LDKNetworkGraph NetworkGraph_new(struct LDKThirtyTwoBytes genesis_hash);
11358
11359 /**
11360  * For an already known node (from channel announcements), update its stored properties from a
11361  * given node announcement.
11362  *
11363  * You probably don't want to call this directly, instead relying on a NetGraphMsgHandler's
11364  * RoutingMessageHandler implementation to call it indirectly. This may be useful to accept
11365  * routing messages from a source using a protocol other than the lightning P2P protocol.
11366  */
11367 MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_node_from_announcement(struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg);
11368
11369 /**
11370  * For an already known node (from channel announcements), update its stored properties from a
11371  * given node announcement without verifying the associated signatures. Because we aren't
11372  * given the associated signatures here we cannot relay the node announcement to any of our
11373  * peers.
11374  */
11375 MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_node_from_unsigned_announcement(struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR msg);
11376
11377 /**
11378  * Store or update channel info from a channel announcement.
11379  *
11380  * You probably don't want to call this directly, instead relying on a NetGraphMsgHandler's
11381  * RoutingMessageHandler implementation to call it indirectly. This may be useful to accept
11382  * routing messages from a source using a protocol other than the lightning P2P protocol.
11383  *
11384  * If a `chain::Access` object is provided via `chain_access`, it will be called to verify
11385  * the corresponding UTXO exists on chain and is correctly-formatted.
11386  */
11387 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);
11388
11389 /**
11390  * Store or update channel info from a channel announcement without verifying the associated
11391  * signatures. Because we aren't given the associated signatures here we cannot relay the
11392  * channel announcement to any of our peers.
11393  *
11394  * If a `chain::Access` object is provided via `chain_access`, it will be called to verify
11395  * the corresponding UTXO exists on chain and is correctly-formatted.
11396  */
11397 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);
11398
11399 /**
11400  * Close a channel if a corresponding HTLC fail was sent.
11401  * If permanent, removes a channel from the local storage.
11402  * May cause the removal of nodes too, if this was their last channel.
11403  * If not permanent, makes channels unavailable for routing.
11404  */
11405 void NetworkGraph_close_channel_from_update(struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id, bool is_permanent);
11406
11407 /**
11408  * For an already known (from announcement) channel, update info about one of the directions
11409  * of the channel.
11410  *
11411  * You probably don't want to call this directly, instead relying on a NetGraphMsgHandler's
11412  * RoutingMessageHandler implementation to call it indirectly. This may be useful to accept
11413  * routing messages from a source using a protocol other than the lightning P2P protocol.
11414  */
11415 MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel(struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg);
11416
11417 /**
11418  * For an already known (from announcement) channel, update info about one of the directions
11419  * of the channel without verifying the associated signatures. Because we aren't given the
11420  * associated signatures here we cannot relay the channel update to any of our peers.
11421  */
11422 MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel_unsigned(struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKUnsignedChannelUpdate *NONNULL_PTR msg);
11423
11424 /* Text to put at the end of the generated file */