Update auto-generated bindings with lightning-invoice
authorMatt Corallo <git@bluematt.me>
Thu, 29 Apr 2021 18:58:26 +0000 (18:58 +0000)
committerMatt Corallo <git@bluematt.me>
Thu, 29 Apr 2021 20:40:35 +0000 (20:40 +0000)
31 files changed:
lightning-c-bindings/include/lightning.h
lightning-c-bindings/include/lightningpp.hpp
lightning-c-bindings/include/rust_types.h
lightning-c-bindings/src/c_types/derived.rs
lightning-c-bindings/src/lib.rs
lightning-c-bindings/src/lightning/chain/chaininterface.rs
lightning-c-bindings/src/lightning/chain/chainmonitor.rs
lightning-c-bindings/src/lightning/chain/channelmonitor.rs
lightning-c-bindings/src/lightning/chain/keysinterface.rs
lightning-c-bindings/src/lightning/chain/mod.rs
lightning-c-bindings/src/lightning/chain/transaction.rs
lightning-c-bindings/src/lightning/ln/chan_utils.rs
lightning-c-bindings/src/lightning/ln/channelmanager.rs
lightning-c-bindings/src/lightning/ln/features.rs
lightning-c-bindings/src/lightning/ln/mod.rs
lightning-c-bindings/src/lightning/ln/msgs.rs
lightning-c-bindings/src/lightning/ln/peer_handler.rs
lightning-c-bindings/src/lightning/mod.rs
lightning-c-bindings/src/lightning/routing/mod.rs
lightning-c-bindings/src/lightning/routing/network_graph.rs
lightning-c-bindings/src/lightning/routing/router.rs
lightning-c-bindings/src/lightning/util/config.rs
lightning-c-bindings/src/lightning/util/errors.rs
lightning-c-bindings/src/lightning/util/events.rs
lightning-c-bindings/src/lightning/util/logger.rs
lightning-c-bindings/src/lightning/util/message_signing.rs
lightning-c-bindings/src/lightning/util/mod.rs
lightning-c-bindings/src/lightning/util/ser.rs
lightning-c-bindings/src/lightning_invoice/constants.rs [new file with mode: 0644]
lightning-c-bindings/src/lightning_invoice/mod.rs [new file with mode: 0644]
lightning-c-bindings/src/lightning_persister.rs

index 4ae3d0bfd5822f6d769f70199ac4182e783fb88d..fba5cc1ace3ab106b08274cf9b1e207f73967611 100644 (file)
@@ -1,7 +1,7 @@
 #ifndef LDK_C_BINDINGS_H
 #define LDK_C_BINDINGS_H
 
-/* Generated with cbindgen:0.16.0 */
+/* Generated with cbindgen:0.19.0 */
 
 /* Warning, this file is autogenerated by cbindgen. Don't modify this manually. */
 
@@ -121,6 +121,58 @@ typedef enum LDKConfirmationTarget {
    LDKConfirmationTarget_Sentinel,
 } LDKConfirmationTarget;
 
+/**
+ * Errors that may occur when constructing a new `RawInvoice` or `Invoice`
+ */
+typedef enum LDKCreationError {
+   /**
+    * The supplied description string was longer than 639 __bytes__ (see [`Description::new(…)`](./struct.Description.html#method.new))
+    */
+   LDKCreationError_DescriptionTooLong,
+   /**
+    * The specified route has too many hops and can't be encoded
+    */
+   LDKCreationError_RouteTooLong,
+   /**
+    * The unix timestamp of the supplied date is <0 or can't be represented as `SystemTime`
+    */
+   LDKCreationError_TimestampOutOfBounds,
+   /**
+    * The supplied expiry time could cause an overflow if added to a `PositiveTimestamp`
+    */
+   LDKCreationError_ExpiryTimeOutOfBounds,
+   /**
+    * Must be last for serialization purposes
+    */
+   LDKCreationError_Sentinel,
+} LDKCreationError;
+
+/**
+ * Enum representing the crypto currencies (or networks) supported by this library
+ */
+typedef enum LDKCurrency {
+   /**
+    * Bitcoin mainnet
+    */
+   LDKCurrency_Bitcoin,
+   /**
+    * Bitcoin testnet
+    */
+   LDKCurrency_BitcoinTestnet,
+   /**
+    * Bitcoin regtest
+    */
+   LDKCurrency_Regtest,
+   /**
+    * Bitcoin simnet/signet
+    */
+   LDKCurrency_Simnet,
+   /**
+    * Must be last for serialization purposes
+    */
+   LDKCurrency_Sentinel,
+} LDKCurrency;
+
 /**
  * Represents an IO Error. Note that some information is lost in the conversion from Rust.
  */
@@ -255,6 +307,67 @@ typedef enum LDKSecp256k1Error {
    LDKSecp256k1Error_Sentinel,
 } LDKSecp256k1Error;
 
+/**
+ * Errors that may occur when converting a `RawInvoice` to an `Invoice`. They relate to the
+ * requirements sections in BOLT #11
+ */
+typedef enum LDKSemanticError {
+   /**
+    * The invoice is missing the mandatory payment hash
+    */
+   LDKSemanticError_NoPaymentHash,
+   /**
+    * The invoice has multiple payment hashes which isn't allowed
+    */
+   LDKSemanticError_MultiplePaymentHashes,
+   /**
+    * No description or description hash are part of the invoice
+    */
+   LDKSemanticError_NoDescription,
+   /**
+    * The invoice contains multiple descriptions and/or description hashes which isn't allowed
+    */
+   LDKSemanticError_MultipleDescriptions,
+   /**
+    * The recovery id doesn't fit the signature/pub key
+    */
+   LDKSemanticError_InvalidRecoveryId,
+   /**
+    * The invoice's signature is invalid
+    */
+   LDKSemanticError_InvalidSignature,
+   /**
+    * Must be last for serialization purposes
+    */
+   LDKSemanticError_Sentinel,
+} LDKSemanticError;
+
+/**
+ * SI prefixes for the human readable part
+ */
+typedef enum LDKSiPrefix {
+   /**
+    * 10^-3
+    */
+   LDKSiPrefix_Milli,
+   /**
+    * 10^-6
+    */
+   LDKSiPrefix_Micro,
+   /**
+    * 10^-9
+    */
+   LDKSiPrefix_Nano,
+   /**
+    * 10^-12
+    */
+   LDKSiPrefix_Pico,
+   /**
+    * Must be last for serialization purposes
+    */
+   LDKSiPrefix_Sentinel,
+} LDKSiPrefix;
+
 /**
  * A serialized transaction, in (pointer, length) form.
  *
@@ -318,6 +431,25 @@ typedef struct LDKTxOut {
    uint64_t value;
 } LDKTxOut;
 
+/**
+ * A Rust str object, ie a reference to a UTF8-valid string.
+ * This is *not* null-terminated so cannot be used directly as a C string!
+ */
+typedef struct LDKStr {
+   /**
+    * A pointer to the string's bytes, in UTF8 encoding
+    */
+   const uint8_t *chars;
+   /**
+    * The number of bytes (not characters!) pointed to by `chars`
+    */
+   uintptr_t len;
+   /**
+    * Whether the data pointed to by `chars` should be freed or not.
+    */
+   bool chars_is_owned;
+} LDKStr;
+
 
 
 /**
@@ -1154,14656 +1286,16199 @@ typedef struct LDKCResult_CVec_SignatureZNoneZ {
    bool result_ok;
 } LDKCResult_CVec_SignatureZNoneZ;
 
-/**
- * The contents of CResult_StringErrorZ
- */
-typedef union LDKCResult_StringErrorZPtr {
-   /**
-    * A pointer to the contents in the success state.
-    * Reading from this pointer when `result_ok` is not set is undefined.
-    */
-   struct LDKCVec_u8Z *result;
-   /**
-    * A pointer to the contents in the error state.
-    * Reading from this pointer when `result_ok` is set is undefined.
-    */
-   enum LDKSecp256k1Error *err;
-} LDKCResult_StringErrorZPtr;
+
 
 /**
- * A CResult_StringErrorZ represents the result of a fallible operation,
- * containing a crate::c_types::derived::CVec_u8Z on success and a crate::c_types::Secp256k1Error on failure.
- * `result_ok` indicates the overall state, and the contents are provided via `contents`.
+ * SHA-256 hash
  */
-typedef struct LDKCResult_StringErrorZ {
+typedef struct MUST_USE_STRUCT LDKSha256 {
    /**
-    * The contents of this CResult_StringErrorZ, accessible via either
-    * `err` or `result` depending on the state of `result_ok`.
+    * A pointer to the opaque Rust object.
+    * Nearly everywhere, inner must be non-null, however in places where
+    * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   union LDKCResult_StringErrorZPtr contents;
+   LDKnativeSha256 *inner;
    /**
-    * Whether this CResult_StringErrorZ represents a success state.
+    * Indicates that this is the only struct which contains the same pointer.
+    * Rust functions which take ownership of an object provided via an argument require
+    * this to be true and invalidate the object pointed to by inner.
     */
-   bool result_ok;
-} LDKCResult_StringErrorZ;
+   bool is_owned;
+} LDKSha256;
 
 
 
 /**
- * An update generated by the underlying Channel itself which contains some new information the
- * ChannelMonitor should be made aware of.
+ * Description string
+ *
+ * # Invariants
+ * The description can be at most 639 __bytes__ long
  */
-typedef struct MUST_USE_STRUCT LDKChannelMonitorUpdate {
+typedef struct MUST_USE_STRUCT LDKDescription {
    /**
     * A pointer to the opaque Rust object.
     * Nearly everywhere, inner must be non-null, however in places where
     * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   LDKnativeChannelMonitorUpdate *inner;
+   LDKnativeDescription *inner;
    /**
     * Indicates that this is the only struct which contains the same pointer.
     * Rust functions which take ownership of an object provided via an argument require
     * this to be true and invalidate the object pointed to by inner.
     */
    bool is_owned;
-} LDKChannelMonitorUpdate;
+} LDKDescription;
+
+
 
 /**
- * The contents of CResult_ChannelMonitorUpdateDecodeErrorZ
+ * Payee public key
  */
-typedef union LDKCResult_ChannelMonitorUpdateDecodeErrorZPtr {
+typedef struct MUST_USE_STRUCT LDKPayeePubKey {
    /**
-    * A pointer to the contents in the success state.
-    * Reading from this pointer when `result_ok` is not set is undefined.
+    * A pointer to the opaque Rust object.
+    * Nearly everywhere, inner must be non-null, however in places where
+    * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   struct LDKChannelMonitorUpdate *result;
+   LDKnativePayeePubKey *inner;
    /**
-    * A pointer to the contents in the error state.
-    * Reading from this pointer when `result_ok` is set is undefined.
+    * Indicates that this is the only struct which contains the same pointer.
+    * Rust functions which take ownership of an object provided via an argument require
+    * this to be true and invalidate the object pointed to by inner.
     */
-   struct LDKDecodeError *err;
-} LDKCResult_ChannelMonitorUpdateDecodeErrorZPtr;
+   bool is_owned;
+} LDKPayeePubKey;
+
+
 
 /**
- * A CResult_ChannelMonitorUpdateDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::chain::channelmonitor::ChannelMonitorUpdate on success and a crate::lightning::ln::msgs::DecodeError on failure.
- * `result_ok` indicates the overall state, and the contents are provided via `contents`.
+ * Positive duration that defines when (relatively to the timestamp) in the future the invoice
+ * expires
+ *
+ * # Invariants
+ * The number of seconds this expiry time represents has to be in the range
+ * `0...(SYSTEM_TIME_MAX_UNIX_TIMESTAMP - MAX_EXPIRY_TIME)` to avoid overflows when adding it to a
+ * timestamp
  */
-typedef struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ {
+typedef struct MUST_USE_STRUCT LDKExpiryTime {
    /**
-    * The contents of this CResult_ChannelMonitorUpdateDecodeErrorZ, accessible via either
-    * `err` or `result` depending on the state of `result_ok`.
+    * A pointer to the opaque Rust object.
+    * Nearly everywhere, inner must be non-null, however in places where
+    * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   union LDKCResult_ChannelMonitorUpdateDecodeErrorZPtr contents;
+   LDKnativeExpiryTime *inner;
    /**
-    * Whether this CResult_ChannelMonitorUpdateDecodeErrorZ represents a success state.
+    * Indicates that this is the only struct which contains the same pointer.
+    * Rust functions which take ownership of an object provided via an argument require
+    * this to be true and invalidate the object pointed to by inner.
     */
-   bool result_ok;
-} LDKCResult_ChannelMonitorUpdateDecodeErrorZ;
+   bool is_owned;
+} LDKExpiryTime;
 
 
 
 /**
- * Simple structure sent back by `chain::Watch` when an HTLC from a forward channel is detected on
- * chain. Used to update the corresponding HTLC in the backward channel. Failing to pass the
- * preimage claim backward will lead to loss of funds.
+ * `min_final_cltv_expiry` to use for the last HTLC in the route
  */
-typedef struct MUST_USE_STRUCT LDKHTLCUpdate {
+typedef struct MUST_USE_STRUCT LDKMinFinalCltvExpiry {
    /**
     * A pointer to the opaque Rust object.
     * Nearly everywhere, inner must be non-null, however in places where
     * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   LDKnativeHTLCUpdate *inner;
+   LDKnativeMinFinalCltvExpiry *inner;
    /**
     * Indicates that this is the only struct which contains the same pointer.
     * Rust functions which take ownership of an object provided via an argument require
     * this to be true and invalidate the object pointed to by inner.
     */
    bool is_owned;
-} LDKHTLCUpdate;
+} LDKMinFinalCltvExpiry;
 
 /**
- * The contents of CResult_HTLCUpdateDecodeErrorZ
+ * Integer in the range `0..32`
  */
-typedef union LDKCResult_HTLCUpdateDecodeErrorZPtr {
-   /**
-    * A pointer to the contents in the success state.
-    * Reading from this pointer when `result_ok` is not set is undefined.
-    */
-   struct LDKHTLCUpdate *result;
-   /**
-    * A pointer to the contents in the error state.
-    * Reading from this pointer when `result_ok` is set is undefined.
-    */
-   struct LDKDecodeError *err;
-} LDKCResult_HTLCUpdateDecodeErrorZPtr;
+typedef struct LDKu5 {
+   uint8_t _0;
+} LDKu5;
 
 /**
- * A CResult_HTLCUpdateDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::chain::channelmonitor::HTLCUpdate on success and a crate::lightning::ln::msgs::DecodeError on failure.
- * `result_ok` indicates the overall state, and the contents are provided via `contents`.
+ * A 20-byte byte array.
  */
-typedef struct LDKCResult_HTLCUpdateDecodeErrorZ {
+typedef struct LDKTwentyBytes {
    /**
-    * The contents of this CResult_HTLCUpdateDecodeErrorZ, accessible via either
-    * `err` or `result` depending on the state of `result_ok`.
+    * The twenty bytes
     */
-   union LDKCResult_HTLCUpdateDecodeErrorZPtr contents;
+   uint8_t data[20];
+} LDKTwentyBytes;
+
+/**
+ * Fallback address in case no LN payment is possible
+ */
+typedef enum LDKFallback_Tag {
+   LDKFallback_SegWitProgram,
+   LDKFallback_PubKeyHash,
+   LDKFallback_ScriptHash,
    /**
-    * Whether this CResult_HTLCUpdateDecodeErrorZ represents a success state.
+    * Must be last for serialization purposes
     */
-   bool result_ok;
-} LDKCResult_HTLCUpdateDecodeErrorZ;
+   LDKFallback_Sentinel,
+} LDKFallback_Tag;
+
+typedef struct LDKFallback_LDKSegWitProgram_Body {
+   struct LDKu5 version;
+   struct LDKCVec_u8Z program;
+} LDKFallback_LDKSegWitProgram_Body;
+
+typedef struct MUST_USE_STRUCT LDKFallback {
+   LDKFallback_Tag tag;
+   union {
+      LDKFallback_LDKSegWitProgram_Body seg_wit_program;
+      struct {
+         struct LDKTwentyBytes pub_key_hash;
+      };
+      struct {
+         struct LDKTwentyBytes script_hash;
+      };
+   };
+} LDKFallback;
 
 
 
 /**
- * General Err type for ChannelMonitor actions. Generally, this implies that the data provided is
- * inconsistent with the ChannelMonitor being called. eg for ChannelMonitor::update_monitor this
- * means you tried to update a monitor for a different channel or the ChannelMonitorUpdate was
- * corrupted.
- * Contains a developer-readable error message.
+ * Private routing information
+ *
+ * # Invariants
+ * The encoded route has to be <1024 5bit characters long (<=639 bytes or <=12 hops)
+ *
  */
-typedef struct MUST_USE_STRUCT LDKMonitorUpdateError {
+typedef struct MUST_USE_STRUCT LDKRouteHint {
    /**
     * A pointer to the opaque Rust object.
     * Nearly everywhere, inner must be non-null, however in places where
     * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   LDKnativeMonitorUpdateError *inner;
+   LDKnativeRouteHint *inner;
    /**
     * Indicates that this is the only struct which contains the same pointer.
     * Rust functions which take ownership of an object provided via an argument require
     * this to be true and invalidate the object pointed to by inner.
     */
    bool is_owned;
-} LDKMonitorUpdateError;
+} LDKRouteHint;
+
+
 
 /**
- * The contents of CResult_NoneMonitorUpdateErrorZ
+ * 256-bit payment secret
  */
-typedef union LDKCResult_NoneMonitorUpdateErrorZPtr {
+typedef struct MUST_USE_STRUCT LDKPaymentSecret {
    /**
-    * Note that this value is always NULL, as there are no contents in the OK variant
+    * A pointer to the opaque Rust object.
+    * Nearly everywhere, inner must be non-null, however in places where
+    * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   void *result;
+   LDKnativePaymentSecret *inner;
    /**
-    * A pointer to the contents in the error state.
-    * Reading from this pointer when `result_ok` is set is undefined.
+    * Indicates that this is the only struct which contains the same pointer.
+    * Rust functions which take ownership of an object provided via an argument require
+    * this to be true and invalidate the object pointed to by inner.
     */
-   struct LDKMonitorUpdateError *err;
-} LDKCResult_NoneMonitorUpdateErrorZPtr;
+   bool is_owned;
+} LDKPaymentSecret;
+
+
 
 /**
- * A CResult_NoneMonitorUpdateErrorZ represents the result of a fallible operation,
- * containing a () on success and a crate::lightning::chain::channelmonitor::MonitorUpdateError on failure.
- * `result_ok` indicates the overall state, and the contents are provided via `contents`.
+ * Features used within an invoice.
  */
-typedef struct LDKCResult_NoneMonitorUpdateErrorZ {
+typedef struct MUST_USE_STRUCT LDKInvoiceFeatures {
    /**
-    * The contents of this CResult_NoneMonitorUpdateErrorZ, accessible via either
-    * `err` or `result` depending on the state of `result_ok`.
+    * A pointer to the opaque Rust object.
+    * Nearly everywhere, inner must be non-null, however in places where
+    * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   union LDKCResult_NoneMonitorUpdateErrorZPtr contents;
+   LDKnativeInvoiceFeatures *inner;
    /**
-    * Whether this CResult_NoneMonitorUpdateErrorZ represents a success state.
+    * Indicates that this is the only struct which contains the same pointer.
+    * Rust functions which take ownership of an object provided via an argument require
+    * this to be true and invalidate the object pointed to by inner.
     */
-   bool result_ok;
-} LDKCResult_NoneMonitorUpdateErrorZ;
+   bool is_owned;
+} LDKInvoiceFeatures;
 
 /**
- * A tuple of 2 elements. See the individual fields for the types contained.
- */
-typedef struct LDKC2Tuple_OutPointScriptZ {
-   /**
-    * The element at position 0
-    */
-   struct LDKOutPoint a;
+ * Tagged field with known tag
+ *
+ * For descriptions of the enum values please refer to the enclosed type's docs.
+ */
+typedef enum LDKTaggedField_Tag {
+   LDKTaggedField_PaymentHash,
+   LDKTaggedField_Description,
+   LDKTaggedField_PayeePubKey,
+   LDKTaggedField_DescriptionHash,
+   LDKTaggedField_ExpiryTime,
+   LDKTaggedField_MinFinalCltvExpiry,
+   LDKTaggedField_Fallback,
+   LDKTaggedField_Route,
+   LDKTaggedField_PaymentSecret,
+   LDKTaggedField_Features,
    /**
-    * The element at position 1
+    * Must be last for serialization purposes
     */
-   struct LDKCVec_u8Z b;
-} LDKC2Tuple_OutPointScriptZ;
-
-/**
- * A tuple of 2 elements. See the individual fields for the types contained.
- */
-typedef struct LDKC2Tuple_u32ScriptZ {
-   /**
-    * The element at position 0
-    */
-   uint32_t a;
-   /**
-    * The element at position 1
-    */
-   struct LDKCVec_u8Z b;
-} LDKC2Tuple_u32ScriptZ;
-
-/**
- * A dynamically-allocated array of crate::c_types::derived::C2Tuple_u32ScriptZs of arbitrary size.
- * This corresponds to std::vector in C++
- */
-typedef struct LDKCVec_C2Tuple_u32ScriptZZ {
-   /**
-    * The elements in the array.
-    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
-    */
-   struct LDKC2Tuple_u32ScriptZ *data;
-   /**
-    * The number of elements pointed to by `data`.
-    */
-   uintptr_t datalen;
-} LDKCVec_C2Tuple_u32ScriptZZ;
-
-/**
- * Arbitrary 32 bytes, which could represent one of a few different things. You probably want to
- * look up the corresponding function in rust-lightning's docs.
- */
-typedef struct LDKThirtyTwoBytes {
-   /**
-    * The thirty-two bytes
-    */
-   uint8_t data[32];
-} LDKThirtyTwoBytes;
+   LDKTaggedField_Sentinel,
+} LDKTaggedField_Tag;
 
-/**
- * A tuple of 2 elements. See the individual fields for the types contained.
- */
-typedef struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ {
-   /**
-    * The element at position 0
-    */
-   struct LDKThirtyTwoBytes a;
-   /**
-    * The element at position 1
-    */
-   struct LDKCVec_C2Tuple_u32ScriptZZ b;
-} LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ;
+typedef struct MUST_USE_STRUCT LDKTaggedField {
+   LDKTaggedField_Tag tag;
+   union {
+      struct {
+         struct LDKSha256 payment_hash;
+      };
+      struct {
+         struct LDKDescription description;
+      };
+      struct {
+         struct LDKPayeePubKey payee_pub_key;
+      };
+      struct {
+         struct LDKSha256 description_hash;
+      };
+      struct {
+         struct LDKExpiryTime expiry_time;
+      };
+      struct {
+         struct LDKMinFinalCltvExpiry min_final_cltv_expiry;
+      };
+      struct {
+         struct LDKFallback fallback;
+      };
+      struct {
+         struct LDKRouteHint route;
+      };
+      struct {
+         struct LDKPaymentSecret payment_secret;
+      };
+      struct {
+         struct LDKInvoiceFeatures features;
+      };
+   };
+} LDKTaggedField;
 
 /**
- * A dynamically-allocated array of crate::c_types::derived::C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZs of arbitrary size.
+ * A dynamically-allocated array of crate::c_types::u5s of arbitrary size.
  * This corresponds to std::vector in C++
  */
-typedef struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ {
+typedef struct LDKCVec_u5Z {
    /**
     * The elements in the array.
     * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
     */
-   struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *data;
+   struct LDKu5 *data;
    /**
     * The number of elements pointed to by `data`.
     */
    uintptr_t datalen;
-} LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ;
+} LDKCVec_u5Z;
 
 /**
- * An event to be processed by the ChannelManager.
+ * Tagged field which may have an unknown tag
  */
-typedef enum LDKMonitorEvent_Tag {
+typedef enum LDKRawTaggedField_Tag {
    /**
-    * A monitor event containing an HTLCUpdate.
+    * Parsed tagged field with known tag
     */
-   LDKMonitorEvent_HTLCEvent,
+   LDKRawTaggedField_KnownSemantics,
    /**
-    * A monitor event that the Channel's commitment transaction was broadcasted.
+    * tagged field which was not parsed due to an unknown tag or undefined field semantics
     */
-   LDKMonitorEvent_CommitmentTxBroadcasted,
+   LDKRawTaggedField_UnknownSemantics,
    /**
     * Must be last for serialization purposes
     */
-   LDKMonitorEvent_Sentinel,
-} LDKMonitorEvent_Tag;
+   LDKRawTaggedField_Sentinel,
+} LDKRawTaggedField_Tag;
 
-typedef struct MUST_USE_STRUCT LDKMonitorEvent {
-   LDKMonitorEvent_Tag tag;
+typedef struct MUST_USE_STRUCT LDKRawTaggedField {
+   LDKRawTaggedField_Tag tag;
    union {
       struct {
-         struct LDKHTLCUpdate htlc_event;
+         struct LDKTaggedField known_semantics;
       };
       struct {
-         struct LDKOutPoint commitment_tx_broadcasted;
+         struct LDKCVec_u5Z unknown_semantics;
       };
    };
-} LDKMonitorEvent;
+} LDKRawTaggedField;
 
 /**
- * A dynamically-allocated array of crate::lightning::chain::channelmonitor::MonitorEvents of arbitrary size.
+ * A dynamically-allocated array of crate::lightning_invoice::RawTaggedFields of arbitrary size.
  * This corresponds to std::vector in C++
  */
-typedef struct LDKCVec_MonitorEventZ {
+typedef struct LDKCVec_RawTaggedFieldZ {
    /**
     * The elements in the array.
     * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
     */
-   struct LDKMonitorEvent *data;
+   struct LDKRawTaggedField *data;
    /**
     * The number of elements pointed to by `data`.
     */
    uintptr_t datalen;
-} LDKCVec_MonitorEventZ;
+} LDKCVec_RawTaggedFieldZ;
 
 
 
 /**
- * Information about a spendable output to a P2WSH script. See
- * SpendableOutputDescriptor::DelayedPaymentOutput for more details on how to spend this.
+ * Represents an syntactically correct Invoice for a payment on the lightning network,
+ * but without the signature information.
+ * De- and encoding should not lead to information loss but may lead to different hashes.
+ *
+ * For methods without docs see the corresponding methods in `Invoice`.
  */
-typedef struct MUST_USE_STRUCT LDKDelayedPaymentOutputDescriptor {
+typedef struct MUST_USE_STRUCT LDKRawInvoice {
    /**
     * A pointer to the opaque Rust object.
     * Nearly everywhere, inner must be non-null, however in places where
     * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   LDKnativeDelayedPaymentOutputDescriptor *inner;
+   LDKnativeRawInvoice *inner;
    /**
     * Indicates that this is the only struct which contains the same pointer.
     * Rust functions which take ownership of an object provided via an argument require
     * this to be true and invalidate the object pointed to by inner.
     */
    bool is_owned;
-} LDKDelayedPaymentOutputDescriptor;
+} LDKRawInvoice;
+
+/**
+ * Arbitrary 32 bytes, which could represent one of a few different things. You probably want to
+ * look up the corresponding function in rust-lightning's docs.
+ */
+typedef struct LDKThirtyTwoBytes {
+   /**
+    * The thirty-two bytes
+    */
+   uint8_t data[32];
+} LDKThirtyTwoBytes;
 
 
 
 /**
- * Information about a spendable output to our \"payment key\". See
- * SpendableOutputDescriptor::StaticPaymentOutput for more details on how to spend this.
+ * Recoverable signature
  */
-typedef struct MUST_USE_STRUCT LDKStaticPaymentOutputDescriptor {
+typedef struct MUST_USE_STRUCT LDKInvoiceSignature {
    /**
     * A pointer to the opaque Rust object.
     * Nearly everywhere, inner must be non-null, however in places where
     * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   LDKnativeStaticPaymentOutputDescriptor *inner;
+   LDKnativeInvoiceSignature *inner;
    /**
     * Indicates that this is the only struct which contains the same pointer.
     * Rust functions which take ownership of an object provided via an argument require
     * this to be true and invalidate the object pointed to by inner.
     */
    bool is_owned;
-} LDKStaticPaymentOutputDescriptor;
+} LDKInvoiceSignature;
 
 /**
- * When on-chain outputs are created by rust-lightning (which our counterparty is not able to
- * claim at any point in the future) an event is generated which you must track and be able to
- * spend on-chain. The information needed to do this is provided in this enum, including the
- * outpoint describing which txid and output index is available, the full output which exists at
- * that txid/index, and any keys or other information required to sign.
+ * A tuple of 3 elements. See the individual fields for the types contained.
  */
-typedef enum LDKSpendableOutputDescriptor_Tag {
+typedef struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ {
    /**
-    * An output to a script which was provided via KeysInterface directly, either from
-    * `get_destination_script()` or `get_shutdown_pubkey()`, thus you should already know how to
-    * spend it. No secret keys are provided as rust-lightning was never given any key.
-    * These may include outputs from a transaction punishing our counterparty or claiming an HTLC
-    * on-chain using the payment preimage or after it has timed out.
+    * The element at position 0
     */
-   LDKSpendableOutputDescriptor_StaticOutput,
+   struct LDKRawInvoice a;
    /**
-    * An output to a P2WSH script which can be spent with a single signature after a CSV delay.
-    *
-    * The witness in the spending input should be:
-    * <BIP 143 signature> <empty vector> (MINIMALIF standard rule) <provided witnessScript>
-    *
-    * Note that the nSequence field in the spending input must be set to to_self_delay
-    * (which means the transaction is not broadcastable until at least to_self_delay
-    * blocks after the outpoint confirms).
-    *
-    * These are generally the result of a \"revocable\" output to us, spendable only by us unless
-    * it is an output from an old state which we broadcast (which should never happen).
-    *
-    * To derive the delayed_payment key which is used to sign for this input, you must pass the
-    * holder delayed_payment_base_key (ie the private key which corresponds to the pubkey in
-    * Sign::pubkeys().delayed_payment_basepoint) and the provided per_commitment_point to
-    * chan_utils::derive_private_key. The public key can be generated without the secret key
-    * using chan_utils::derive_public_key and only the delayed_payment_basepoint which appears in
-    * Sign::pubkeys().
-    *
-    * To derive the revocation_pubkey provided here (which is used in the witness
-    * script generation), you must pass the counterparty revocation_basepoint (which appears in the
-    * call to Sign::ready_channel) and the provided per_commitment point
-    * to chan_utils::derive_public_revocation_key.
-    *
-    * The witness script which is hashed and included in the output script_pubkey may be
-    * regenerated by passing the revocation_pubkey (derived as above), our delayed_payment pubkey
-    * (derived as above), and the to_self_delay contained here to
-    * chan_utils::get_revokeable_redeemscript.
+    * The element at position 1
     */
-   LDKSpendableOutputDescriptor_DelayedPaymentOutput,
+   struct LDKThirtyTwoBytes b;
    /**
-    * An output to a P2WPKH, spendable exclusively by our payment key (ie the private key which
-    * corresponds to the public key in Sign::pubkeys().payment_point).
-    * The witness in the spending input, is, thus, simply:
-    * <BIP 143 signature> <payment key>
-    *
-    * These are generally the result of our counterparty having broadcast the current state,
-    * allowing us to claim the non-HTLC-encumbered outputs immediately.
+    * The element at position 2
     */
-   LDKSpendableOutputDescriptor_StaticPaymentOutput,
+   struct LDKInvoiceSignature c;
+} LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ;
+
+/**
+ * The contents of CResult_PayeePubKeyErrorZ
+ */
+typedef union LDKCResult_PayeePubKeyErrorZPtr {
    /**
-    * Must be last for serialization purposes
+    * A pointer to the contents in the success state.
+    * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   LDKSpendableOutputDescriptor_Sentinel,
-} LDKSpendableOutputDescriptor_Tag;
+   struct LDKPayeePubKey *result;
+   /**
+    * A pointer to the contents in the error state.
+    * Reading from this pointer when `result_ok` is set is undefined.
+    */
+   enum LDKSecp256k1Error *err;
+} LDKCResult_PayeePubKeyErrorZPtr;
 
-typedef struct LDKSpendableOutputDescriptor_LDKStaticOutput_Body {
+/**
+ * A CResult_PayeePubKeyErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning_invoice::PayeePubKey on success and a crate::c_types::Secp256k1Error on failure.
+ * `result_ok` indicates the overall state, and the contents are provided via `contents`.
+ */
+typedef struct LDKCResult_PayeePubKeyErrorZ {
    /**
-    * The outpoint which is spendable
+    * The contents of this CResult_PayeePubKeyErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   struct LDKOutPoint outpoint;
+   union LDKCResult_PayeePubKeyErrorZPtr contents;
    /**
-    * The output which is referenced by the given outpoint.
+    * Whether this CResult_PayeePubKeyErrorZ represents a success state.
     */
-   struct LDKTxOut output;
-} LDKSpendableOutputDescriptor_LDKStaticOutput_Body;
-
-typedef struct MUST_USE_STRUCT LDKSpendableOutputDescriptor {
-   LDKSpendableOutputDescriptor_Tag tag;
-   union {
-      LDKSpendableOutputDescriptor_LDKStaticOutput_Body static_output;
-      struct {
-         struct LDKDelayedPaymentOutputDescriptor delayed_payment_output;
-      };
-      struct {
-         struct LDKStaticPaymentOutputDescriptor static_payment_output;
-      };
-   };
-} LDKSpendableOutputDescriptor;
+   bool result_ok;
+} LDKCResult_PayeePubKeyErrorZ;
 
 /**
- * A dynamically-allocated array of crate::lightning::chain::keysinterface::SpendableOutputDescriptors of arbitrary size.
+ * A dynamically-allocated array of crate::lightning_invoice::RouteHints of arbitrary size.
  * This corresponds to std::vector in C++
  */
-typedef struct LDKCVec_SpendableOutputDescriptorZ {
+typedef struct LDKCVec_RouteHintZ {
    /**
     * The elements in the array.
     * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
     */
-   struct LDKSpendableOutputDescriptor *data;
+   struct LDKRouteHint *data;
    /**
     * The number of elements pointed to by `data`.
     */
    uintptr_t datalen;
-} LDKCVec_SpendableOutputDescriptorZ;
+} LDKCVec_RouteHintZ;
 
 /**
- * An Event which you should probably take some action in response to.
- *
- * Note that while Writeable and Readable are implemented for Event, you probably shouldn't use
- * them directly as they don't round-trip exactly (for example FundingGenerationReady is never
- * written as it makes no sense to respond to it after reconnecting to peers).
+ * An enum which can either contain a u64 or not
  */
-typedef enum LDKEvent_Tag {
-   /**
-    * Used to indicate that the client should generate a funding transaction with the given
-    * parameters and then call ChannelManager::funding_transaction_generated.
-    * Generated in ChannelManager message handling.
-    * Note that *all inputs* in the funding transaction must spend SegWit outputs or your
-    * counterparty can steal your funds!
-    */
-   LDKEvent_FundingGenerationReady,
+typedef enum LDKCOption_u64Z_Tag {
    /**
-    * Indicates we've received money! Just gotta dig out that payment preimage and feed it to
-    * ChannelManager::claim_funds to get it....
-    * Note that if the preimage is not known or the amount paid is incorrect, you should call
-    * ChannelManager::fail_htlc_backwards to free up resources for this HTLC and avoid
-    * network congestion.
-    * The amount paid should be considered 'incorrect' when it is less than or more than twice
-    * the amount expected.
-    * If you fail to call either ChannelManager::claim_funds or
-    * ChannelManager::fail_htlc_backwards within the HTLC's timeout, the HTLC will be
-    * automatically failed.
+    * When we're in this state, this COption_u64Z contains a u64
     */
-   LDKEvent_PaymentReceived,
+   LDKCOption_u64Z_Some,
    /**
-    * Indicates an outbound payment we made succeeded (ie it made it all the way to its target
-    * and we got back the payment preimage for it).
-    * Note that duplicative PaymentSent Events may be generated - it is your responsibility to
-    * deduplicate them by payment_preimage (which MUST be unique)!
+    * When we're in this state, this COption_u64Z contains nothing
     */
-   LDKEvent_PaymentSent,
+   LDKCOption_u64Z_None,
    /**
-    * Indicates an outbound payment we made failed. Probably some intermediary node dropped
-    * something. You may wish to retry with a different route.
-    * Note that duplicative PaymentFailed Events may be generated - it is your responsibility to
-    * deduplicate them by payment_hash (which MUST be unique)!
+    * Must be last for serialization purposes
     */
-   LDKEvent_PaymentFailed,
-   /**
-    * Used to indicate that ChannelManager::process_pending_htlc_forwards should be called at a
-    * time in the future.
-    */
-   LDKEvent_PendingHTLCsForwardable,
-   /**
-    * Used to indicate that an output was generated on-chain which you should know how to spend.
-    * Such an output will *not* ever be spent by rust-lightning, and are not at risk of your
-    * counterparty spending them due to some kind of timeout. Thus, you need to store them
-    * somewhere and spend them when you create on-chain transactions.
-    */
-   LDKEvent_SpendableOutputs,
-   /**
-    * Must be last for serialization purposes
-    */
-   LDKEvent_Sentinel,
-} LDKEvent_Tag;
+   LDKCOption_u64Z_Sentinel,
+} LDKCOption_u64Z_Tag;
 
-typedef struct LDKEvent_LDKFundingGenerationReady_Body {
-   /**
-    * The random channel_id we picked which you'll need to pass into
-    * ChannelManager::funding_transaction_generated.
-    */
-   struct LDKThirtyTwoBytes temporary_channel_id;
-   /**
-    * The value, in satoshis, that the output should have.
-    */
-   uint64_t channel_value_satoshis;
+typedef struct LDKCOption_u64Z {
+   LDKCOption_u64Z_Tag tag;
+   union {
+      struct {
+         uint64_t some;
+      };
+   };
+} LDKCOption_u64Z;
+
+
+
+/**
+ * A timestamp that refers to a date after 1 January 1970 which means its representation as UNIX
+ * timestamp is positive.
+ *
+ * # Invariants
+ * The UNIX timestamp representing the stored time has to be positive and small enough so that
+ * a `EpiryTime` can be added to it without an overflow.
+ */
+typedef struct MUST_USE_STRUCT LDKPositiveTimestamp {
    /**
-    * The script which should be used in the transaction output.
+    * A pointer to the opaque Rust object.
+    * Nearly everywhere, inner must be non-null, however in places where
+    * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   struct LDKCVec_u8Z output_script;
+   LDKnativePositiveTimestamp *inner;
    /**
-    * The value passed in to ChannelManager::create_channel
+    * Indicates that this is the only struct which contains the same pointer.
+    * Rust functions which take ownership of an object provided via an argument require
+    * this to be true and invalidate the object pointed to by inner.
     */
-   uint64_t user_channel_id;
-} LDKEvent_LDKFundingGenerationReady_Body;
+   bool is_owned;
+} LDKPositiveTimestamp;
 
-typedef struct LDKEvent_LDKPaymentReceived_Body {
+/**
+ * The contents of CResult_PositiveTimestampCreationErrorZ
+ */
+typedef union LDKCResult_PositiveTimestampCreationErrorZPtr {
    /**
-    * The hash for which the preimage should be handed to the ChannelManager.
+    * A pointer to the contents in the success state.
+    * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKThirtyTwoBytes payment_hash;
+   struct LDKPositiveTimestamp *result;
    /**
-    * The \"payment secret\". This authenticates the sender to the recipient, preventing a
-    * number of deanonymization attacks during the routing process.
-    * As nodes upgrade, the invoices you provide should likely migrate to setting the
-    * payment_secret feature to required, at which point you should fail_backwards any HTLCs
-    * which have a None here.
-    * Until then, however, values of None should be ignored, and only incorrect Some values
-    * should result in an HTLC fail_backwards.
-    * Note that, in any case, this value must be passed as-is to any fail or claim calls as
-    * the HTLC index includes this value.
+    * A pointer to the contents in the error state.
+    * Reading from this pointer when `result_ok` is set is undefined.
     */
-   struct LDKThirtyTwoBytes payment_secret;
+   enum LDKCreationError *err;
+} LDKCResult_PositiveTimestampCreationErrorZPtr;
+
+/**
+ * A CResult_PositiveTimestampCreationErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning_invoice::PositiveTimestamp on success and a crate::lightning_invoice::CreationError on failure.
+ * `result_ok` indicates the overall state, and the contents are provided via `contents`.
+ */
+typedef struct LDKCResult_PositiveTimestampCreationErrorZ {
    /**
-    * The value, in thousandths of a satoshi, that this payment is for. Note that you must
-    * compare this to the expected value before accepting the payment (as otherwise you are
-    * providing proof-of-payment for less than the value you expected!).
+    * The contents of this CResult_PositiveTimestampCreationErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   uint64_t amt;
-} LDKEvent_LDKPaymentReceived_Body;
-
-typedef struct LDKEvent_LDKPaymentSent_Body {
+   union LDKCResult_PositiveTimestampCreationErrorZPtr contents;
    /**
-    * The preimage to the hash given to ChannelManager::send_payment.
-    * Note that this serves as a payment receipt, if you wish to have such a thing, you must
-    * store it somehow!
+    * Whether this CResult_PositiveTimestampCreationErrorZ represents a success state.
     */
-   struct LDKThirtyTwoBytes payment_preimage;
-} LDKEvent_LDKPaymentSent_Body;
+   bool result_ok;
+} LDKCResult_PositiveTimestampCreationErrorZ;
 
-typedef struct LDKEvent_LDKPaymentFailed_Body {
+/**
+ * The contents of CResult_NoneSemanticErrorZ
+ */
+typedef union LDKCResult_NoneSemanticErrorZPtr {
    /**
-    * The hash which was given to ChannelManager::send_payment.
+    * Note that this value is always NULL, as there are no contents in the OK variant
     */
-   struct LDKThirtyTwoBytes payment_hash;
+   void *result;
    /**
-    * Indicates the payment was rejected for some reason by the recipient. This implies that
-    * the payment has failed, not just the route in question. If this is not set, you may
-    * retry the payment via a different route.
+    * A pointer to the contents in the error state.
+    * Reading from this pointer when `result_ok` is set is undefined.
     */
-   bool rejected_by_dest;
-} LDKEvent_LDKPaymentFailed_Body;
+   enum LDKSemanticError *err;
+} LDKCResult_NoneSemanticErrorZPtr;
 
-typedef struct LDKEvent_LDKPendingHTLCsForwardable_Body {
+/**
+ * A CResult_NoneSemanticErrorZ represents the result of a fallible operation,
+ * containing a () on success and a crate::lightning_invoice::SemanticError on failure.
+ * `result_ok` indicates the overall state, and the contents are provided via `contents`.
+ */
+typedef struct LDKCResult_NoneSemanticErrorZ {
    /**
-    * The minimum amount of time that should be waited prior to calling
-    * process_pending_htlc_forwards. To increase the effort required to correlate payments,
-    * you should wait a random amount of time in roughly the range (now + time_forwardable,
-    * now + 5*time_forwardable).
+    * The contents of this CResult_NoneSemanticErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   uint64_t time_forwardable;
-} LDKEvent_LDKPendingHTLCsForwardable_Body;
-
-typedef struct LDKEvent_LDKSpendableOutputs_Body {
+   union LDKCResult_NoneSemanticErrorZPtr contents;
    /**
-    * The outputs which you should store as spendable by you.
+    * Whether this CResult_NoneSemanticErrorZ represents a success state.
     */
-   struct LDKCVec_SpendableOutputDescriptorZ outputs;
-} LDKEvent_LDKSpendableOutputs_Body;
+   bool result_ok;
+} LDKCResult_NoneSemanticErrorZ;
+
 
-typedef struct MUST_USE_STRUCT LDKEvent {
-   LDKEvent_Tag tag;
-   union {
-      LDKEvent_LDKFundingGenerationReady_Body funding_generation_ready;
-      LDKEvent_LDKPaymentReceived_Body payment_received;
-      LDKEvent_LDKPaymentSent_Body payment_sent;
-      LDKEvent_LDKPaymentFailed_Body payment_failed;
-      LDKEvent_LDKPendingHTLCsForwardable_Body pending_htl_cs_forwardable;
-      LDKEvent_LDKSpendableOutputs_Body spendable_outputs;
-   };
-} LDKEvent;
 
 /**
- * A dynamically-allocated array of crate::lightning::util::events::Events of arbitrary size.
- * This corresponds to std::vector in C++
+ * Represents a syntactically and semantically correct lightning BOLT11 invoice.
+ *
+ * There are three ways to construct an `Invoice`:
+ *  1. using `InvoiceBuilder`
+ *  2. using `Invoice::from_signed(SignedRawInvoice)`
+ *  3. using `str::parse::<Invoice>(&str)`
  */
-typedef struct LDKCVec_EventZ {
+typedef struct MUST_USE_STRUCT LDKInvoice {
    /**
-    * The elements in the array.
-    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+    * A pointer to the opaque Rust object.
+    * Nearly everywhere, inner must be non-null, however in places where
+    * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   struct LDKEvent *data;
+   LDKnativeInvoice *inner;
    /**
-    * The number of elements pointed to by `data`.
+    * Indicates that this is the only struct which contains the same pointer.
+    * Rust functions which take ownership of an object provided via an argument require
+    * this to be true and invalidate the object pointed to by inner.
     */
-   uintptr_t datalen;
-} LDKCVec_EventZ;
+   bool is_owned;
+} LDKInvoice;
 
 /**
- * A dynamically-allocated array of crate::c_types::Transactions of arbitrary size.
- * This corresponds to std::vector in C++
+ * The contents of CResult_InvoiceSemanticErrorZ
  */
-typedef struct LDKCVec_TransactionZ {
+typedef union LDKCResult_InvoiceSemanticErrorZPtr {
    /**
-    * The elements in the array.
-    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+    * A pointer to the contents in the success state.
+    * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKTransaction *data;
+   struct LDKInvoice *result;
    /**
-    * The number of elements pointed to by `data`.
+    * A pointer to the contents in the error state.
+    * Reading from this pointer when `result_ok` is set is undefined.
     */
-   uintptr_t datalen;
-} LDKCVec_TransactionZ;
+   enum LDKSemanticError *err;
+} LDKCResult_InvoiceSemanticErrorZPtr;
 
 /**
- * A tuple of 2 elements. See the individual fields for the types contained.
+ * A CResult_InvoiceSemanticErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning_invoice::Invoice on success and a crate::lightning_invoice::SemanticError on failure.
+ * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKC2Tuple_usizeTransactionZ {
+typedef struct LDKCResult_InvoiceSemanticErrorZ {
    /**
-    * The element at position 0
+    * The contents of this CResult_InvoiceSemanticErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   uintptr_t a;
+   union LDKCResult_InvoiceSemanticErrorZPtr contents;
    /**
-    * The element at position 1
+    * Whether this CResult_InvoiceSemanticErrorZ represents a success state.
     */
-   struct LDKTransaction b;
-} LDKC2Tuple_usizeTransactionZ;
+   bool result_ok;
+} LDKCResult_InvoiceSemanticErrorZ;
 
 /**
- * A dynamically-allocated array of crate::c_types::derived::C2Tuple_usizeTransactionZs of arbitrary size.
- * This corresponds to std::vector in C++
+ * The contents of CResult_DescriptionCreationErrorZ
  */
-typedef struct LDKCVec_C2Tuple_usizeTransactionZZ {
+typedef union LDKCResult_DescriptionCreationErrorZPtr {
    /**
-    * The elements in the array.
-    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+    * A pointer to the contents in the success state.
+    * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKC2Tuple_usizeTransactionZ *data;
+   struct LDKDescription *result;
    /**
-    * The number of elements pointed to by `data`.
+    * A pointer to the contents in the error state.
+    * Reading from this pointer when `result_ok` is set is undefined.
     */
-   uintptr_t datalen;
-} LDKCVec_C2Tuple_usizeTransactionZZ;
+   enum LDKCreationError *err;
+} LDKCResult_DescriptionCreationErrorZPtr;
 
 /**
- * A tuple of 2 elements. See the individual fields for the types contained.
+ * A CResult_DescriptionCreationErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning_invoice::Description on success and a crate::lightning_invoice::CreationError on failure.
+ * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKC2Tuple_u32TxOutZ {
+typedef struct LDKCResult_DescriptionCreationErrorZ {
    /**
-    * The element at position 0
+    * The contents of this CResult_DescriptionCreationErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   uint32_t a;
+   union LDKCResult_DescriptionCreationErrorZPtr contents;
    /**
-    * The element at position 1
+    * Whether this CResult_DescriptionCreationErrorZ represents a success state.
     */
-   struct LDKTxOut b;
-} LDKC2Tuple_u32TxOutZ;
+   bool result_ok;
+} LDKCResult_DescriptionCreationErrorZ;
 
 /**
- * A dynamically-allocated array of crate::c_types::derived::C2Tuple_u32TxOutZs of arbitrary size.
- * This corresponds to std::vector in C++
+ * The contents of CResult_ExpiryTimeCreationErrorZ
  */
-typedef struct LDKCVec_C2Tuple_u32TxOutZZ {
+typedef union LDKCResult_ExpiryTimeCreationErrorZPtr {
    /**
-    * The elements in the array.
-    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+    * A pointer to the contents in the success state.
+    * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKC2Tuple_u32TxOutZ *data;
+   struct LDKExpiryTime *result;
    /**
-    * The number of elements pointed to by `data`.
+    * A pointer to the contents in the error state.
+    * Reading from this pointer when `result_ok` is set is undefined.
     */
-   uintptr_t datalen;
-} LDKCVec_C2Tuple_u32TxOutZZ;
+   enum LDKCreationError *err;
+} LDKCResult_ExpiryTimeCreationErrorZPtr;
 
 /**
- * A tuple of 2 elements. See the individual fields for the types contained.
+ * A CResult_ExpiryTimeCreationErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning_invoice::ExpiryTime on success and a crate::lightning_invoice::CreationError on failure.
+ * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ {
+typedef struct LDKCResult_ExpiryTimeCreationErrorZ {
    /**
-    * The element at position 0
+    * The contents of this CResult_ExpiryTimeCreationErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   struct LDKThirtyTwoBytes a;
+   union LDKCResult_ExpiryTimeCreationErrorZPtr contents;
    /**
-    * The element at position 1
+    * Whether this CResult_ExpiryTimeCreationErrorZ represents a success state.
     */
-   struct LDKCVec_C2Tuple_u32TxOutZZ b;
-} LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ;
+   bool result_ok;
+} LDKCResult_ExpiryTimeCreationErrorZ;
+
+
 
 /**
- * A dynamically-allocated array of crate::c_types::derived::C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZs of arbitrary size.
- * This corresponds to std::vector in C++
+ * A channel descriptor which provides a last-hop route to get_route
  */
-typedef struct LDKCVec_TransactionOutputsZ {
+typedef struct MUST_USE_STRUCT LDKRouteHintHop {
    /**
-    * The elements in the array.
-    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+    * A pointer to the opaque Rust object.
+    * Nearly everywhere, inner must be non-null, however in places where
+    * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *data;
+   LDKnativeRouteHintHop *inner;
    /**
-    * The number of elements pointed to by `data`.
+    * Indicates that this is the only struct which contains the same pointer.
+    * Rust functions which take ownership of an object provided via an argument require
+    * this to be true and invalidate the object pointed to by inner.
     */
-   uintptr_t datalen;
-} LDKCVec_TransactionOutputsZ;
+   bool is_owned;
+} LDKRouteHintHop;
 
 /**
- * A dynamically-allocated array of crate::c_types::ThirtyTwoBytess of arbitrary size.
+ * A dynamically-allocated array of crate::lightning::routing::router::RouteHintHops of arbitrary size.
  * This corresponds to std::vector in C++
  */
-typedef struct LDKCVec_TxidZ {
+typedef struct LDKCVec_RouteHintHopZ {
    /**
     * The elements in the array.
     * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
     */
-   struct LDKThirtyTwoBytes *data;
+   struct LDKRouteHintHop *data;
    /**
     * The number of elements pointed to by `data`.
     */
    uintptr_t datalen;
-} LDKCVec_TxidZ;
+} LDKCVec_RouteHintHopZ;
 
 /**
- * The contents of CResult_NoneChannelMonitorUpdateErrZ
+ * The contents of CResult_RouteHintCreationErrorZ
  */
-typedef union LDKCResult_NoneChannelMonitorUpdateErrZPtr {
+typedef union LDKCResult_RouteHintCreationErrorZPtr {
    /**
-    * Note that this value is always NULL, as there are no contents in the OK variant
+    * A pointer to the contents in the success state.
+    * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   void *result;
+   struct LDKRouteHint *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
-   enum LDKChannelMonitorUpdateErr *err;
-} LDKCResult_NoneChannelMonitorUpdateErrZPtr;
+   enum LDKCreationError *err;
+} LDKCResult_RouteHintCreationErrorZPtr;
 
 /**
- * A CResult_NoneChannelMonitorUpdateErrZ represents the result of a fallible operation,
- * containing a () on success and a crate::lightning::chain::channelmonitor::ChannelMonitorUpdateErr on failure.
+ * A CResult_RouteHintCreationErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning_invoice::RouteHint on success and a crate::lightning_invoice::CreationError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_NoneChannelMonitorUpdateErrZ {
+typedef struct LDKCResult_RouteHintCreationErrorZ {
    /**
-    * The contents of this CResult_NoneChannelMonitorUpdateErrZ, accessible via either
+    * The contents of this CResult_RouteHintCreationErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_NoneChannelMonitorUpdateErrZPtr contents;
+   union LDKCResult_RouteHintCreationErrorZPtr contents;
    /**
-    * Whether this CResult_NoneChannelMonitorUpdateErrZ represents a success state.
+    * Whether this CResult_RouteHintCreationErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_NoneChannelMonitorUpdateErrZ;
+} LDKCResult_RouteHintCreationErrorZ;
 
 /**
- * A tuple of 2 elements. See the individual fields for the types contained.
+ * The contents of CResult_StringErrorZ
  */
-typedef struct LDKC2Tuple_SignatureCVec_SignatureZZ {
+typedef union LDKCResult_StringErrorZPtr {
    /**
-    * The element at position 0
+    * A pointer to the contents in the success state.
+    * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKSignature a;
+   struct LDKCVec_u8Z *result;
    /**
-    * The element at position 1
+    * A pointer to the contents in the error state.
+    * Reading from this pointer when `result_ok` is set is undefined.
     */
-   struct LDKCVec_SignatureZ b;
-} LDKC2Tuple_SignatureCVec_SignatureZZ;
+   enum LDKSecp256k1Error *err;
+} LDKCResult_StringErrorZPtr;
 
 /**
- * The contents of CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ
+ * A CResult_StringErrorZ represents the result of a fallible operation,
+ * containing a crate::c_types::derived::CVec_u8Z on success and a crate::c_types::Secp256k1Error on failure.
+ * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef union LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZPtr {
+typedef struct LDKCResult_StringErrorZ {
+   /**
+    * The contents of this CResult_StringErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
+    */
+   union LDKCResult_StringErrorZPtr contents;
+   /**
+    * Whether this CResult_StringErrorZ represents a success state.
+    */
+   bool result_ok;
+} LDKCResult_StringErrorZ;
+
+
+
+/**
+ * An update generated by the underlying Channel itself which contains some new information the
+ * ChannelMonitor should be made aware of.
+ */
+typedef struct MUST_USE_STRUCT LDKChannelMonitorUpdate {
+   /**
+    * A pointer to the opaque Rust object.
+    * Nearly everywhere, inner must be non-null, however in places where
+    * the Rust equivalent takes an Option, it may be set to null to indicate None.
+    */
+   LDKnativeChannelMonitorUpdate *inner;
+   /**
+    * Indicates that this is the only struct which contains the same pointer.
+    * Rust functions which take ownership of an object provided via an argument require
+    * this to be true and invalidate the object pointed to by inner.
+    */
+   bool is_owned;
+} LDKChannelMonitorUpdate;
+
+/**
+ * The contents of CResult_ChannelMonitorUpdateDecodeErrorZ
+ */
+typedef union LDKCResult_ChannelMonitorUpdateDecodeErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKC2Tuple_SignatureCVec_SignatureZZ *result;
+   struct LDKChannelMonitorUpdate *result;
    /**
-    * Note that this value is always NULL, as there are no contents in the Err variant
+    * A pointer to the contents in the error state.
+    * Reading from this pointer when `result_ok` is set is undefined.
     */
-   void *err;
-} LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZPtr;
+   struct LDKDecodeError *err;
+} LDKCResult_ChannelMonitorUpdateDecodeErrorZPtr;
 
 /**
- * A CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ represents the result of a fallible operation,
- * containing a crate::c_types::derived::C2Tuple_SignatureCVec_SignatureZZ on success and a () on failure.
+ * A CResult_ChannelMonitorUpdateDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::chain::channelmonitor::ChannelMonitorUpdate on success and a crate::lightning::ln::msgs::DecodeError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ {
+typedef struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ {
    /**
-    * The contents of this CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ, accessible via either
+    * The contents of this CResult_ChannelMonitorUpdateDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZPtr contents;
+   union LDKCResult_ChannelMonitorUpdateDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ represents a success state.
+    * Whether this CResult_ChannelMonitorUpdateDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ;
+} LDKCResult_ChannelMonitorUpdateDecodeErrorZ;
+
+
 
 /**
- * The contents of CResult_SignatureNoneZ
+ * Simple structure sent back by `chain::Watch` when an HTLC from a forward channel is detected on
+ * chain. Used to update the corresponding HTLC in the backward channel. Failing to pass the
+ * preimage claim backward will lead to loss of funds.
  */
-typedef union LDKCResult_SignatureNoneZPtr {
+typedef struct MUST_USE_STRUCT LDKHTLCUpdate {
+   /**
+    * A pointer to the opaque Rust object.
+    * Nearly everywhere, inner must be non-null, however in places where
+    * the Rust equivalent takes an Option, it may be set to null to indicate None.
+    */
+   LDKnativeHTLCUpdate *inner;
+   /**
+    * Indicates that this is the only struct which contains the same pointer.
+    * Rust functions which take ownership of an object provided via an argument require
+    * this to be true and invalidate the object pointed to by inner.
+    */
+   bool is_owned;
+} LDKHTLCUpdate;
+
+/**
+ * The contents of CResult_HTLCUpdateDecodeErrorZ
+ */
+typedef union LDKCResult_HTLCUpdateDecodeErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKSignature *result;
+   struct LDKHTLCUpdate *result;
    /**
-    * Note that this value is always NULL, as there are no contents in the Err variant
+    * A pointer to the contents in the error state.
+    * Reading from this pointer when `result_ok` is set is undefined.
     */
-   void *err;
-} LDKCResult_SignatureNoneZPtr;
+   struct LDKDecodeError *err;
+} LDKCResult_HTLCUpdateDecodeErrorZPtr;
 
 /**
- * A CResult_SignatureNoneZ represents the result of a fallible operation,
- * containing a crate::c_types::Signature on success and a () on failure.
+ * A CResult_HTLCUpdateDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::chain::channelmonitor::HTLCUpdate on success and a crate::lightning::ln::msgs::DecodeError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_SignatureNoneZ {
+typedef struct LDKCResult_HTLCUpdateDecodeErrorZ {
    /**
-    * The contents of this CResult_SignatureNoneZ, accessible via either
+    * The contents of this CResult_HTLCUpdateDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_SignatureNoneZPtr contents;
+   union LDKCResult_HTLCUpdateDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_SignatureNoneZ represents a success state.
+    * Whether this CResult_HTLCUpdateDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_SignatureNoneZ;
+} LDKCResult_HTLCUpdateDecodeErrorZ;
 
 
 
 /**
- * The unsigned part of a channel_announcement
+ * General Err type for ChannelMonitor actions. Generally, this implies that the data provided is
+ * inconsistent with the ChannelMonitor being called. eg for ChannelMonitor::update_monitor this
+ * means you tried to update a monitor for a different channel or the ChannelMonitorUpdate was
+ * corrupted.
+ * Contains a developer-readable error message.
  */
-typedef struct MUST_USE_STRUCT LDKUnsignedChannelAnnouncement {
+typedef struct MUST_USE_STRUCT LDKMonitorUpdateError {
    /**
     * A pointer to the opaque Rust object.
     * Nearly everywhere, inner must be non-null, however in places where
     * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   LDKnativeUnsignedChannelAnnouncement *inner;
+   LDKnativeMonitorUpdateError *inner;
    /**
     * Indicates that this is the only struct which contains the same pointer.
     * Rust functions which take ownership of an object provided via an argument require
     * this to be true and invalidate the object pointed to by inner.
     */
    bool is_owned;
-} LDKUnsignedChannelAnnouncement;
+} LDKMonitorUpdateError;
 
 /**
- * A trait to sign lightning channel transactions as described in BOLT 3.
- *
- * Signing services could be implemented on a hardware wallet. In this case,
- * the current Sign would be a front-end on top of a communication
- * channel connected to your secure device and lightning key material wouldn't
- * reside on a hot server. Nevertheless, a this deployment would still need
- * to trust the ChannelManager to avoid loss of funds as this latest component
- * could ask to sign commitment transaction with HTLCs paying to attacker pubkeys.
- *
- * A more secure iteration would be to use hashlock (or payment points) to pair
- * invoice/incoming HTLCs with outgoing HTLCs to implement a no-trust-ChannelManager
- * at the price of more state and computation on the hardware wallet side. In the future,
- * we are looking forward to design such interface.
- *
- * In any case, ChannelMonitor or fallback watchtowers are always going to be trusted
- * to act, as liveness and breach reply correctness are always going to be hard requirements
- * of LN security model, orthogonal of key management issues.
+ * The contents of CResult_NoneMonitorUpdateErrorZ
  */
-typedef struct LDKBaseSign {
+typedef union LDKCResult_NoneMonitorUpdateErrorZPtr {
    /**
-    * An opaque pointer which is passed to your function implementations as an argument.
-    * This has no meaning in the LDK, and can be NULL or any other value.
+    * Note that this value is always NULL, as there are no contents in the OK variant
     */
-   void *this_arg;
+   void *result;
    /**
-    * Gets the per-commitment point for a specific commitment number
-    *
-    * Note that the commitment number starts at (1 << 48) - 1 and counts backwards.
+    * A pointer to the contents in the error state.
+    * Reading from this pointer when `result_ok` is set is undefined.
     */
-   struct LDKPublicKey (*get_per_commitment_point)(const void *this_arg, uint64_t idx);
+   struct LDKMonitorUpdateError *err;
+} LDKCResult_NoneMonitorUpdateErrorZPtr;
+
+/**
+ * A CResult_NoneMonitorUpdateErrorZ represents the result of a fallible operation,
+ * containing a () on success and a crate::lightning::chain::channelmonitor::MonitorUpdateError on failure.
+ * `result_ok` indicates the overall state, and the contents are provided via `contents`.
+ */
+typedef struct LDKCResult_NoneMonitorUpdateErrorZ {
    /**
-    * Gets the commitment secret for a specific commitment number as part of the revocation process
-    *
-    * An external signer implementation should error here if the commitment was already signed
-    * and should refuse to sign it in the future.
-    *
-    * May be called more than once for the same index.
-    *
-    * Note that the commitment number starts at (1 << 48) - 1 and counts backwards.
+    * The contents of this CResult_NoneMonitorUpdateErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   struct LDKThirtyTwoBytes (*release_commitment_secret)(const void *this_arg, uint64_t idx);
+   union LDKCResult_NoneMonitorUpdateErrorZPtr contents;
    /**
-    * Gets the holder's channel public keys and basepoints
+    * Whether this CResult_NoneMonitorUpdateErrorZ represents a success state.
     */
-   struct LDKChannelPublicKeys pubkeys;
+   bool result_ok;
+} LDKCResult_NoneMonitorUpdateErrorZ;
+
+/**
+ * A tuple of 2 elements. See the individual fields for the types contained.
+ */
+typedef struct LDKC2Tuple_OutPointScriptZ {
    /**
-    * Fill in the pubkeys field as a reference to it will be given to Rust after this returns
-    * Note that this takes a pointer to this object, not the this_ptr like other methods do
-    * This function pointer may be NULL if pubkeys is filled in when this object is created and never needs updating.
+    * The element at position 0
     */
-   void (*set_pubkeys)(const struct LDKBaseSign*NONNULL_PTR );
+   struct LDKOutPoint a;
    /**
-    * Gets an arbitrary identifier describing the set of keys which are provided back to you in
-    * some SpendableOutputDescriptor types. This should be sufficient to identify this
-    * Sign object uniquely and lookup or re-derive its keys.
+    * The element at position 1
     */
-   struct LDKThirtyTwoBytes (*channel_keys_id)(const void *this_arg);
+   struct LDKCVec_u8Z b;
+} LDKC2Tuple_OutPointScriptZ;
+
+/**
+ * A tuple of 2 elements. See the individual fields for the types contained.
+ */
+typedef struct LDKC2Tuple_u32ScriptZ {
    /**
-    * Create a signature for a counterparty's commitment transaction and associated HTLC transactions.
-    *
-    * Note that if signing fails or is rejected, the channel will be force-closed.
+    * The element at position 0
     */
-   struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ (*sign_counterparty_commitment)(const void *this_arg, const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx);
+   uint32_t a;
    /**
-    * Create a signatures for a holder's commitment transaction and its claiming HTLC transactions.
-    * This will only ever be called with a non-revoked commitment_tx.  This will be called with the
-    * latest commitment_tx when we initiate a force-close.
-    * This will be called with the previous latest, just to get claiming HTLC signatures, if we are
-    * reacting to a ChannelMonitor replica that decided to broadcast before it had been updated to
-    * the latest.
-    * This may be called multiple times for the same transaction.
-    *
-    * An external signer implementation should check that the commitment has not been revoked.
-    *
-    * May return Err if key derivation fails.  Callers, such as ChannelMonitor, will panic in such a case.
+    * The element at position 1
     */
-   struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ (*sign_holder_commitment_and_htlcs)(const void *this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx);
+   struct LDKCVec_u8Z b;
+} LDKC2Tuple_u32ScriptZ;
+
+/**
+ * A dynamically-allocated array of crate::c_types::derived::C2Tuple_u32ScriptZs of arbitrary size.
+ * This corresponds to std::vector in C++
+ */
+typedef struct LDKCVec_C2Tuple_u32ScriptZZ {
    /**
-    * Create a signature for the given input in a transaction spending an HTLC or commitment
-    * transaction output when our counterparty broadcasts an old state.
-    *
-    * A justice transaction may claim multiples outputs at the same time if timelocks are
-    * similar, but only a signature for the input at index `input` should be signed for here.
-    * It may be called multiples time for same output(s) if a fee-bump is needed with regards
-    * to an upcoming timelock expiration.
-    *
-    * Amount is value of the output spent by this input, committed to in the BIP 143 signature.
-    *
-    * per_commitment_key is revocation secret which was provided by our counterparty when they
-    * revoked the state which they eventually broadcast. It's not a _holder_ secret key and does
-    * not allow the spending of any funds by itself (you need our holder revocation_secret to do
-    * so).
-    *
-    * htlc holds HTLC elements (hash, timelock) if the output being spent is a HTLC output, thus
-    * changing the format of the witness script (which is committed to in the BIP 143
-    * signatures).
+    * The elements in the array.
+    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
     */
-   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);
+   struct LDKC2Tuple_u32ScriptZ *data;
    /**
-    * Create a signature for a claiming transaction for a HTLC output on a counterparty's commitment
-    * transaction, either offered or received.
-    *
-    * Such a transaction may claim multiples offered outputs at same time if we know the
-    * preimage for each when we create it, but only the input at index `input` should be
-    * signed for here. It may be called multiple times for same output(s) if a fee-bump is
-    * needed with regards to an upcoming timelock expiration.
-    *
-    * Witness_script is either a offered or received script as defined in BOLT3 for HTLC
-    * outputs.
-    *
-    * Amount is value of the output spent by this input, committed to in the BIP 143 signature.
-    *
-    * Per_commitment_point is the dynamic point corresponding to the channel state
-    * detected onchain. It has been generated by our counterparty and is used to derive
-    * channel state keys, which are then included in the witness script and committed to in the
-    * BIP 143 signature.
+    * The number of elements pointed to by `data`.
     */
-   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);
+   uintptr_t datalen;
+} LDKCVec_C2Tuple_u32ScriptZZ;
+
+/**
+ * A tuple of 2 elements. See the individual fields for the types contained.
+ */
+typedef struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ {
    /**
-    * Create a signature for a (proposed) closing transaction.
-    *
-    * Note that, due to rounding, there may be one \"missing\" satoshi, and either party may have
-    * chosen to forgo their output as dust.
+    * The element at position 0
     */
-   struct LDKCResult_SignatureNoneZ (*sign_closing_transaction)(const void *this_arg, struct LDKTransaction closing_tx);
+   struct LDKThirtyTwoBytes a;
    /**
-    * Signs a channel announcement message with our funding key, proving it comes from one
-    * of the channel participants.
-    *
-    * Note that if this fails or is rejected, the channel will not be publicly announced and
-    * our counterparty may (though likely will not) close the channel on us for violating the
-    * protocol.
+    * The element at position 1
     */
-   struct LDKCResult_SignatureNoneZ (*sign_channel_announcement)(const void *this_arg, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg);
+   struct LDKCVec_C2Tuple_u32ScriptZZ b;
+} LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ;
+
+/**
+ * A dynamically-allocated array of crate::c_types::derived::C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZs of arbitrary size.
+ * This corresponds to std::vector in C++
+ */
+typedef struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ {
    /**
-    * Set the counterparty static channel data, including basepoints,
-    * counterparty_selected/holder_selected_contest_delay and funding outpoint.
-    * This is done as soon as the funding outpoint is known.  Since these are static channel data,
-    * they MUST NOT be allowed to change to different values once set.
-    *
-    * channel_parameters.is_populated() MUST be true.
-    *
-    * We bind holder_selected_contest_delay late here for API convenience.
-    *
-    * Will be called before any signatures are applied.
+    * The elements in the array.
+    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
     */
-   void (*ready_channel)(void *this_arg, const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters);
+   struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *data;
    /**
-    * Frees any resources associated with this object given its this_arg pointer.
-    * Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
+    * The number of elements pointed to by `data`.
     */
-   void (*free)(void *this_arg);
-} LDKBaseSign;
+   uintptr_t datalen;
+} LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ;
 
 /**
- * A cloneable signer.
- *
- * Although we require signers to be cloneable, it may be useful for developers to be able to use
- * signers in an un-sized way, for example as `dyn BaseSign`. Therefore we separate the Clone trait,
- * which implies Sized, into this derived trait.
+ * An event to be processed by the ChannelManager.
  */
-typedef struct LDKSign {
-   /**
-    * An opaque pointer which is passed to your function implementations as an argument.
-    * This has no meaning in the LDK, and can be NULL or any other value.
-    */
-   void *this_arg;
+typedef enum LDKMonitorEvent_Tag {
    /**
-    * Implementation of BaseSign for this object.
+    * A monitor event containing an HTLCUpdate.
     */
-   struct LDKBaseSign BaseSign;
+   LDKMonitorEvent_HTLCEvent,
    /**
-    * Creates a copy of the BaseSign, for a copy of this Sign.
-    * Because BaseSign doesn't natively support copying itself, you have to provide a full copy implementation here.
+    * A monitor event that the Channel's commitment transaction was broadcasted.
     */
-   struct LDKBaseSign (*BaseSign_clone)(const struct LDKBaseSign *NONNULL_PTR orig_BaseSign);
+   LDKMonitorEvent_CommitmentTxBroadcasted,
    /**
-    * Serialize the object into a byte array
+    * Must be last for serialization purposes
     */
-   struct LDKCVec_u8Z (*write)(const void *this_arg);
+   LDKMonitorEvent_Sentinel,
+} LDKMonitorEvent_Tag;
+
+typedef struct MUST_USE_STRUCT LDKMonitorEvent {
+   LDKMonitorEvent_Tag tag;
+   union {
+      struct {
+         struct LDKHTLCUpdate htlc_event;
+      };
+      struct {
+         struct LDKOutPoint commitment_tx_broadcasted;
+      };
+   };
+} LDKMonitorEvent;
+
+/**
+ * A dynamically-allocated array of crate::lightning::chain::channelmonitor::MonitorEvents of arbitrary size.
+ * This corresponds to std::vector in C++
+ */
+typedef struct LDKCVec_MonitorEventZ {
    /**
-    * Creates a copy of the object pointed to by this_arg, for a copy of this Sign.
-    * Note that the ultimate copy of the Sign will have all function pointers the same as the original.
-    * May be NULL if no action needs to be taken, the this_arg pointer will be copied into the new Sign.
+    * The elements in the array.
+    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
     */
-   void *(*clone)(const void *this_arg);
+   struct LDKMonitorEvent *data;
    /**
-    * Frees any resources associated with this object given its this_arg pointer.
-    * Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
+    * The number of elements pointed to by `data`.
     */
-   void (*free)(void *this_arg);
-} LDKSign;
+   uintptr_t datalen;
+} LDKCVec_MonitorEventZ;
 
 
 
 /**
- * A ChannelMonitor handles chain events (blocks connected and disconnected) and generates
- * on-chain transactions to ensure no loss of funds occurs.
- *
- * You MUST ensure that no ChannelMonitors for a given channel anywhere contain out-of-date
- * information and are actively monitoring the chain.
- *
- * Pending Events or updated HTLCs which have not yet been read out by
- * get_and_clear_pending_monitor_events or get_and_clear_pending_events are serialized to disk and
- * reloaded at deserialize-time. Thus, you must ensure that, when handling events, all events
- * gotten are fully handled before re-serializing the new state.
- *
- * Note that the deserializer is only implemented for (BlockHash, ChannelMonitor), which
- * tells you the last block hash which was block_connect()ed. You MUST rescan any blocks along
- * the \"reorg path\" (ie disconnecting blocks until you find a common ancestor from both the
- * returned block hash and the the current chain and then reconnecting blocks to get to the
- * best chain) upon deserializing the object!
+ * Information about a spendable output to a P2WSH script. See
+ * SpendableOutputDescriptor::DelayedPaymentOutput for more details on how to spend this.
  */
-typedef struct MUST_USE_STRUCT LDKChannelMonitor {
+typedef struct MUST_USE_STRUCT LDKDelayedPaymentOutputDescriptor {
    /**
     * A pointer to the opaque Rust object.
     * Nearly everywhere, inner must be non-null, however in places where
     * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   LDKnativeChannelMonitor *inner;
+   LDKnativeDelayedPaymentOutputDescriptor *inner;
    /**
     * Indicates that this is the only struct which contains the same pointer.
     * Rust functions which take ownership of an object provided via an argument require
     * this to be true and invalidate the object pointed to by inner.
     */
    bool is_owned;
-} LDKChannelMonitor;
-
-/**
- * A tuple of 2 elements. See the individual fields for the types contained.
- */
-typedef struct LDKC2Tuple_BlockHashChannelMonitorZ {
-   /**
-    * The element at position 0
-    */
-   struct LDKThirtyTwoBytes a;
-   /**
-    * The element at position 1
-    */
-   struct LDKChannelMonitor b;
-} LDKC2Tuple_BlockHashChannelMonitorZ;
-
-/**
- * The contents of CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ
- */
-typedef union LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZPtr {
-   /**
-    * A pointer to the contents in the success state.
-    * Reading from this pointer when `result_ok` is not set is undefined.
-    */
-   struct LDKC2Tuple_BlockHashChannelMonitorZ *result;
-   /**
-    * A pointer to the contents in the error state.
-    * Reading from this pointer when `result_ok` is set is undefined.
-    */
-   struct LDKDecodeError *err;
-} LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZPtr;
-
-/**
- * A CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::c_types::derived::C2Tuple_BlockHashChannelMonitorZ on success and a crate::lightning::ln::msgs::DecodeError on failure.
- * `result_ok` indicates the overall state, and the contents are provided via `contents`.
- */
-typedef struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ {
-   /**
-    * The contents of this CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ, accessible via either
-    * `err` or `result` depending on the state of `result_ok`.
-    */
-   union LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZPtr contents;
-   /**
-    * Whether this CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ represents a success state.
-    */
-   bool result_ok;
-} LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ;
+} LDKDelayedPaymentOutputDescriptor;
 
 
 
 /**
- * A hop in a route
+ * Information about a spendable output to our \"payment key\". See
+ * SpendableOutputDescriptor::StaticPaymentOutput for more details on how to spend this.
  */
-typedef struct MUST_USE_STRUCT LDKRouteHop {
+typedef struct MUST_USE_STRUCT LDKStaticPaymentOutputDescriptor {
    /**
     * A pointer to the opaque Rust object.
     * Nearly everywhere, inner must be non-null, however in places where
     * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   LDKnativeRouteHop *inner;
+   LDKnativeStaticPaymentOutputDescriptor *inner;
    /**
     * Indicates that this is the only struct which contains the same pointer.
     * Rust functions which take ownership of an object provided via an argument require
     * this to be true and invalidate the object pointed to by inner.
     */
    bool is_owned;
-} LDKRouteHop;
+} LDKStaticPaymentOutputDescriptor;
 
 /**
- * A dynamically-allocated array of crate::lightning::routing::router::RouteHops of arbitrary size.
- * This corresponds to std::vector in C++
+ * When on-chain outputs are created by rust-lightning (which our counterparty is not able to
+ * claim at any point in the future) an event is generated which you must track and be able to
+ * spend on-chain. The information needed to do this is provided in this enum, including the
+ * outpoint describing which txid and output index is available, the full output which exists at
+ * that txid/index, and any keys or other information required to sign.
  */
-typedef struct LDKCVec_RouteHopZ {
-   /**
-    * The elements in the array.
-    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
-    */
-   struct LDKRouteHop *data;
+typedef enum LDKSpendableOutputDescriptor_Tag {
    /**
-    * The number of elements pointed to by `data`.
+    * An output to a script which was provided via KeysInterface directly, either from
+    * `get_destination_script()` or `get_shutdown_pubkey()`, thus you should already know how to
+    * spend it. No secret keys are provided as rust-lightning was never given any key.
+    * These may include outputs from a transaction punishing our counterparty or claiming an HTLC
+    * on-chain using the payment preimage or after it has timed out.
     */
-   uintptr_t datalen;
-} LDKCVec_RouteHopZ;
-
-/**
- * A dynamically-allocated array of crate::c_types::derived::CVec_RouteHopZs of arbitrary size.
- * This corresponds to std::vector in C++
- */
-typedef struct LDKCVec_CVec_RouteHopZZ {
+   LDKSpendableOutputDescriptor_StaticOutput,
    /**
-    * The elements in the array.
-    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+    * An output to a P2WSH script which can be spent with a single signature after a CSV delay.
+    *
+    * The witness in the spending input should be:
+    * <BIP 143 signature> <empty vector> (MINIMALIF standard rule) <provided witnessScript>
+    *
+    * Note that the nSequence field in the spending input must be set to to_self_delay
+    * (which means the transaction is not broadcastable until at least to_self_delay
+    * blocks after the outpoint confirms).
+    *
+    * These are generally the result of a \"revocable\" output to us, spendable only by us unless
+    * it is an output from an old state which we broadcast (which should never happen).
+    *
+    * To derive the delayed_payment key which is used to sign for this input, you must pass the
+    * holder delayed_payment_base_key (ie the private key which corresponds to the pubkey in
+    * Sign::pubkeys().delayed_payment_basepoint) and the provided per_commitment_point to
+    * chan_utils::derive_private_key. The public key can be generated without the secret key
+    * using chan_utils::derive_public_key and only the delayed_payment_basepoint which appears in
+    * Sign::pubkeys().
+    *
+    * To derive the revocation_pubkey provided here (which is used in the witness
+    * script generation), you must pass the counterparty revocation_basepoint (which appears in the
+    * call to Sign::ready_channel) and the provided per_commitment point
+    * to chan_utils::derive_public_revocation_key.
+    *
+    * The witness script which is hashed and included in the output script_pubkey may be
+    * regenerated by passing the revocation_pubkey (derived as above), our delayed_payment pubkey
+    * (derived as above), and the to_self_delay contained here to
+    * chan_utils::get_revokeable_redeemscript.
     */
-   struct LDKCVec_RouteHopZ *data;
+   LDKSpendableOutputDescriptor_DelayedPaymentOutput,
    /**
-    * The number of elements pointed to by `data`.
+    * An output to a P2WPKH, spendable exclusively by our payment key (ie the private key which
+    * corresponds to the public key in Sign::pubkeys().payment_point).
+    * The witness in the spending input, is, thus, simply:
+    * <BIP 143 signature> <payment key>
+    *
+    * These are generally the result of our counterparty having broadcast the current state,
+    * allowing us to claim the non-HTLC-encumbered outputs immediately.
     */
-   uintptr_t datalen;
-} LDKCVec_CVec_RouteHopZZ;
+   LDKSpendableOutputDescriptor_StaticPaymentOutput,
+   /**
+    * Must be last for serialization purposes
+    */
+   LDKSpendableOutputDescriptor_Sentinel,
+} LDKSpendableOutputDescriptor_Tag;
 
+typedef struct LDKSpendableOutputDescriptor_LDKStaticOutput_Body {
+   /**
+    * The outpoint which is spendable
+    */
+   struct LDKOutPoint outpoint;
+   /**
+    * The output which is referenced by the given outpoint.
+    */
+   struct LDKTxOut output;
+} LDKSpendableOutputDescriptor_LDKStaticOutput_Body;
 
+typedef struct MUST_USE_STRUCT LDKSpendableOutputDescriptor {
+   LDKSpendableOutputDescriptor_Tag tag;
+   union {
+      LDKSpendableOutputDescriptor_LDKStaticOutput_Body static_output;
+      struct {
+         struct LDKDelayedPaymentOutputDescriptor delayed_payment_output;
+      };
+      struct {
+         struct LDKStaticPaymentOutputDescriptor static_payment_output;
+      };
+   };
+} LDKSpendableOutputDescriptor;
 
 /**
- * A route directs a payment from the sender (us) to the recipient. If the recipient supports MPP,
- * it can take multiple paths. Each path is composed of one or more hops through the network.
+ * A dynamically-allocated array of crate::lightning::chain::keysinterface::SpendableOutputDescriptors of arbitrary size.
+ * This corresponds to std::vector in C++
  */
-typedef struct MUST_USE_STRUCT LDKRoute {
+typedef struct LDKCVec_SpendableOutputDescriptorZ {
    /**
-    * A pointer to the opaque Rust object.
-    * Nearly everywhere, inner must be non-null, however in places where
-    * the Rust equivalent takes an Option, it may be set to null to indicate None.
+    * The elements in the array.
+    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
     */
-   LDKnativeRoute *inner;
+   struct LDKSpendableOutputDescriptor *data;
    /**
-    * Indicates that this is the only struct which contains the same pointer.
-    * Rust functions which take ownership of an object provided via an argument require
-    * this to be true and invalidate the object pointed to by inner.
+    * The number of elements pointed to by `data`.
     */
-   bool is_owned;
-} LDKRoute;
+   uintptr_t datalen;
+} LDKCVec_SpendableOutputDescriptorZ;
 
 /**
- * The contents of CResult_RouteDecodeErrorZ
+ * An Event which you should probably take some action in response to.
+ *
+ * Note that while Writeable and Readable are implemented for Event, you probably shouldn't use
+ * them directly as they don't round-trip exactly (for example FundingGenerationReady is never
+ * written as it makes no sense to respond to it after reconnecting to peers).
  */
-typedef union LDKCResult_RouteDecodeErrorZPtr {
+typedef enum LDKEvent_Tag {
    /**
-    * A pointer to the contents in the success state.
-    * Reading from this pointer when `result_ok` is not set is undefined.
+    * Used to indicate that the client should generate a funding transaction with the given
+    * parameters and then call ChannelManager::funding_transaction_generated.
+    * Generated in ChannelManager message handling.
+    * Note that *all inputs* in the funding transaction must spend SegWit outputs or your
+    * counterparty can steal your funds!
     */
-   struct LDKRoute *result;
+   LDKEvent_FundingGenerationReady,
    /**
-    * A pointer to the contents in the error state.
-    * Reading from this pointer when `result_ok` is set is undefined.
+    * Indicates we've received money! Just gotta dig out that payment preimage and feed it to
+    * ChannelManager::claim_funds to get it....
+    * Note that if the preimage is not known or the amount paid is incorrect, you should call
+    * ChannelManager::fail_htlc_backwards to free up resources for this HTLC and avoid
+    * network congestion.
+    * The amount paid should be considered 'incorrect' when it is less than or more than twice
+    * the amount expected.
+    * If you fail to call either ChannelManager::claim_funds or
+    * ChannelManager::fail_htlc_backwards within the HTLC's timeout, the HTLC will be
+    * automatically failed.
     */
-   struct LDKDecodeError *err;
-} LDKCResult_RouteDecodeErrorZPtr;
-
-/**
- * A CResult_RouteDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::routing::router::Route on success and a crate::lightning::ln::msgs::DecodeError on failure.
- * `result_ok` indicates the overall state, and the contents are provided via `contents`.
- */
-typedef struct LDKCResult_RouteDecodeErrorZ {
+   LDKEvent_PaymentReceived,
    /**
-    * The contents of this CResult_RouteDecodeErrorZ, accessible via either
-    * `err` or `result` depending on the state of `result_ok`.
+    * Indicates an outbound payment we made succeeded (ie it made it all the way to its target
+    * and we got back the payment preimage for it).
+    * Note that duplicative PaymentSent Events may be generated - it is your responsibility to
+    * deduplicate them by payment_preimage (which MUST be unique)!
     */
-   union LDKCResult_RouteDecodeErrorZPtr contents;
+   LDKEvent_PaymentSent,
    /**
-    * Whether this CResult_RouteDecodeErrorZ represents a success state.
+    * Indicates an outbound payment we made failed. Probably some intermediary node dropped
+    * something. You may wish to retry with a different route.
+    * Note that duplicative PaymentFailed Events may be generated - it is your responsibility to
+    * deduplicate them by payment_hash (which MUST be unique)!
     */
-   bool result_ok;
-} LDKCResult_RouteDecodeErrorZ;
-
-/**
- * An enum which can either contain a u64 or not
- */
-typedef enum LDKCOption_u64Z_Tag {
+   LDKEvent_PaymentFailed,
    /**
-    * When we're in this state, this COption_u64Z contains a u64
+    * Used to indicate that ChannelManager::process_pending_htlc_forwards should be called at a
+    * time in the future.
     */
-   LDKCOption_u64Z_Some,
+   LDKEvent_PendingHTLCsForwardable,
    /**
-    * When we're in this state, this COption_u64Z contains nothing
+    * Used to indicate that an output was generated on-chain which you should know how to spend.
+    * Such an output will *not* ever be spent by rust-lightning, and are not at risk of your
+    * counterparty spending them due to some kind of timeout. Thus, you need to store them
+    * somewhere and spend them when you create on-chain transactions.
     */
-   LDKCOption_u64Z_None,
+   LDKEvent_SpendableOutputs,
    /**
     * Must be last for serialization purposes
     */
-   LDKCOption_u64Z_Sentinel,
-} LDKCOption_u64Z_Tag;
-
-typedef struct LDKCOption_u64Z {
-   LDKCOption_u64Z_Tag tag;
-   union {
-      struct {
-         uint64_t some;
-      };
-   };
-} LDKCOption_u64Z;
-
-
+   LDKEvent_Sentinel,
+} LDKEvent_Tag;
 
-/**
- * Details of a channel, as returned by ChannelManager::list_channels and ChannelManager::list_usable_channels
- */
-typedef struct MUST_USE_STRUCT LDKChannelDetails {
+typedef struct LDKEvent_LDKFundingGenerationReady_Body {
    /**
-    * A pointer to the opaque Rust object.
-    * Nearly everywhere, inner must be non-null, however in places where
-    * the Rust equivalent takes an Option, it may be set to null to indicate None.
+    * The random channel_id we picked which you'll need to pass into
+    * ChannelManager::funding_transaction_generated.
     */
-   LDKnativeChannelDetails *inner;
+   struct LDKThirtyTwoBytes temporary_channel_id;
    /**
-    * Indicates that this is the only struct which contains the same pointer.
-    * Rust functions which take ownership of an object provided via an argument require
-    * this to be true and invalidate the object pointed to by inner.
+    * The value, in satoshis, that the output should have.
     */
-   bool is_owned;
-} LDKChannelDetails;
-
-/**
- * A dynamically-allocated array of crate::lightning::ln::channelmanager::ChannelDetailss of arbitrary size.
- * This corresponds to std::vector in C++
- */
-typedef struct LDKCVec_ChannelDetailsZ {
+   uint64_t channel_value_satoshis;
    /**
-    * The elements in the array.
-    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+    * The script which should be used in the transaction output.
     */
-   struct LDKChannelDetails *data;
+   struct LDKCVec_u8Z output_script;
    /**
-    * The number of elements pointed to by `data`.
+    * The value passed in to ChannelManager::create_channel
     */
-   uintptr_t datalen;
-} LDKCVec_ChannelDetailsZ;
-
-
+   uint64_t user_channel_id;
+} LDKEvent_LDKFundingGenerationReady_Body;
 
-/**
- * A channel descriptor which provides a last-hop route to get_route
- */
-typedef struct MUST_USE_STRUCT LDKRouteHintHop {
+typedef struct LDKEvent_LDKPaymentReceived_Body {
    /**
-    * A pointer to the opaque Rust object.
-    * Nearly everywhere, inner must be non-null, however in places where
-    * the Rust equivalent takes an Option, it may be set to null to indicate None.
+    * The hash for which the preimage should be handed to the ChannelManager.
     */
-   LDKnativeRouteHintHop *inner;
+   struct LDKThirtyTwoBytes payment_hash;
    /**
-    * Indicates that this is the only struct which contains the same pointer.
-    * Rust functions which take ownership of an object provided via an argument require
-    * this to be true and invalidate the object pointed to by inner.
+    * The preimage to the payment_hash, if the payment hash (and secret) were fetched via
+    * [`ChannelManager::create_inbound_payment`]. If provided, this can be handed directly to
+    * [`ChannelManager::claim_funds`].
+    *
+    * [`ChannelManager::create_inbound_payment`]: crate::ln::channelmanager::ChannelManager::create_inbound_payment
+    * [`ChannelManager::claim_funds`]: crate::ln::channelmanager::ChannelManager::claim_funds
     */
-   bool is_owned;
-} LDKRouteHintHop;
-
-/**
- * A dynamically-allocated array of crate::lightning::routing::router::RouteHintHops of arbitrary size.
- * This corresponds to std::vector in C++
- */
-typedef struct LDKCVec_RouteHintHopZ {
+   struct LDKThirtyTwoBytes payment_preimage;
    /**
-    * The elements in the array.
-    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+    * The \"payment secret\". This authenticates the sender to the recipient, preventing a
+    * number of deanonymization attacks during the routing process.
+    * It is provided here for your reference, however its accuracy is enforced directly by
+    * [`ChannelManager`] using the values you previously provided to
+    * [`ChannelManager::create_inbound_payment`] or
+    * [`ChannelManager::create_inbound_payment_for_hash`].
+    *
+    * [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
+    * [`ChannelManager::create_inbound_payment`]: crate::ln::channelmanager::ChannelManager::create_inbound_payment
+    * [`ChannelManager::create_inbound_payment_for_hash`]: crate::ln::channelmanager::ChannelManager::create_inbound_payment_for_hash
     */
-   struct LDKRouteHintHop *data;
+   struct LDKThirtyTwoBytes payment_secret;
    /**
-    * The number of elements pointed to by `data`.
+    * The value, in thousandths of a satoshi, that this payment is for. Note that you must
+    * compare this to the expected value before accepting the payment (as otherwise you are
+    * providing proof-of-payment for less than the value you expected!).
     */
-   uintptr_t datalen;
-} LDKCVec_RouteHintHopZ;
-
-
-
-/**
- * An Err type for failure to process messages.
- */
-typedef struct MUST_USE_STRUCT LDKLightningError {
+   uint64_t amt;
    /**
-    * A pointer to the opaque Rust object.
-    * Nearly everywhere, inner must be non-null, however in places where
-    * the Rust equivalent takes an Option, it may be set to null to indicate None.
+    * This is the `user_payment_id` which was provided to
+    * [`ChannelManager::create_inbound_payment_for_hash`] or
+    * [`ChannelManager::create_inbound_payment`]. It has no meaning inside of LDK and is
+    * simply copied here. It may be used to correlate PaymentReceived events with invoice
+    * metadata stored elsewhere.
+    *
+    * [`ChannelManager::create_inbound_payment`]: crate::ln::channelmanager::ChannelManager::create_inbound_payment
+    * [`ChannelManager::create_inbound_payment_for_hash`]: crate::ln::channelmanager::ChannelManager::create_inbound_payment_for_hash
     */
-   LDKnativeLightningError *inner;
+   uint64_t user_payment_id;
+} LDKEvent_LDKPaymentReceived_Body;
+
+typedef struct LDKEvent_LDKPaymentSent_Body {
    /**
-    * Indicates that this is the only struct which contains the same pointer.
-    * Rust functions which take ownership of an object provided via an argument require
-    * this to be true and invalidate the object pointed to by inner.
+    * The preimage to the hash given to ChannelManager::send_payment.
+    * Note that this serves as a payment receipt, if you wish to have such a thing, you must
+    * store it somehow!
     */
-   bool is_owned;
-} LDKLightningError;
+   struct LDKThirtyTwoBytes payment_preimage;
+} LDKEvent_LDKPaymentSent_Body;
 
-/**
- * The contents of CResult_RouteLightningErrorZ
- */
-typedef union LDKCResult_RouteLightningErrorZPtr {
+typedef struct LDKEvent_LDKPaymentFailed_Body {
    /**
-    * A pointer to the contents in the success state.
-    * Reading from this pointer when `result_ok` is not set is undefined.
+    * The hash which was given to ChannelManager::send_payment.
     */
-   struct LDKRoute *result;
+   struct LDKThirtyTwoBytes payment_hash;
    /**
-    * A pointer to the contents in the error state.
-    * Reading from this pointer when `result_ok` is set is undefined.
+    * Indicates the payment was rejected for some reason by the recipient. This implies that
+    * the payment has failed, not just the route in question. If this is not set, you may
+    * retry the payment via a different route.
     */
-   struct LDKLightningError *err;
-} LDKCResult_RouteLightningErrorZPtr;
+   bool rejected_by_dest;
+} LDKEvent_LDKPaymentFailed_Body;
 
-/**
- * A CResult_RouteLightningErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::routing::router::Route on success and a crate::lightning::ln::msgs::LightningError on failure.
- * `result_ok` indicates the overall state, and the contents are provided via `contents`.
- */
-typedef struct LDKCResult_RouteLightningErrorZ {
+typedef struct LDKEvent_LDKPendingHTLCsForwardable_Body {
    /**
-    * The contents of this CResult_RouteLightningErrorZ, accessible via either
-    * `err` or `result` depending on the state of `result_ok`.
+    * The minimum amount of time that should be waited prior to calling
+    * process_pending_htlc_forwards. To increase the effort required to correlate payments,
+    * you should wait a random amount of time in roughly the range (now + time_forwardable,
+    * now + 5*time_forwardable).
     */
-   union LDKCResult_RouteLightningErrorZPtr contents;
+   uint64_t time_forwardable;
+} LDKEvent_LDKPendingHTLCsForwardable_Body;
+
+typedef struct LDKEvent_LDKSpendableOutputs_Body {
    /**
-    * Whether this CResult_RouteLightningErrorZ represents a success state.
+    * The outputs which you should store as spendable by you.
     */
-   bool result_ok;
-} LDKCResult_RouteLightningErrorZ;
-
+   struct LDKCVec_SpendableOutputDescriptorZ outputs;
+} LDKEvent_LDKSpendableOutputs_Body;
 
+typedef struct MUST_USE_STRUCT LDKEvent {
+   LDKEvent_Tag tag;
+   union {
+      LDKEvent_LDKFundingGenerationReady_Body funding_generation_ready;
+      LDKEvent_LDKPaymentReceived_Body payment_received;
+      LDKEvent_LDKPaymentSent_Body payment_sent;
+      LDKEvent_LDKPaymentFailed_Body payment_failed;
+      LDKEvent_LDKPendingHTLCsForwardable_Body pending_htl_cs_forwardable;
+      LDKEvent_LDKSpendableOutputs_Body spendable_outputs;
+   };
+} LDKEvent;
 
 /**
- * An accept_channel message to be sent or received from a peer
+ * A dynamically-allocated array of crate::lightning::util::events::Events of arbitrary size.
+ * This corresponds to std::vector in C++
  */
-typedef struct MUST_USE_STRUCT LDKAcceptChannel {
+typedef struct LDKCVec_EventZ {
    /**
-    * A pointer to the opaque Rust object.
-    * Nearly everywhere, inner must be non-null, however in places where
-    * the Rust equivalent takes an Option, it may be set to null to indicate None.
+    * The elements in the array.
+    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
     */
-   LDKnativeAcceptChannel *inner;
+   struct LDKEvent *data;
    /**
-    * Indicates that this is the only struct which contains the same pointer.
-    * Rust functions which take ownership of an object provided via an argument require
-    * this to be true and invalidate the object pointed to by inner.
+    * The number of elements pointed to by `data`.
     */
-   bool is_owned;
-} LDKAcceptChannel;
-
-
+   uintptr_t datalen;
+} LDKCVec_EventZ;
 
 /**
- * An open_channel message to be sent or received from a peer
+ * A dynamically-allocated array of crate::c_types::Transactions of arbitrary size.
+ * This corresponds to std::vector in C++
  */
-typedef struct MUST_USE_STRUCT LDKOpenChannel {
+typedef struct LDKCVec_TransactionZ {
    /**
-    * A pointer to the opaque Rust object.
-    * Nearly everywhere, inner must be non-null, however in places where
-    * the Rust equivalent takes an Option, it may be set to null to indicate None.
+    * The elements in the array.
+    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
     */
-   LDKnativeOpenChannel *inner;
+   struct LDKTransaction *data;
    /**
-    * Indicates that this is the only struct which contains the same pointer.
-    * Rust functions which take ownership of an object provided via an argument require
-    * this to be true and invalidate the object pointed to by inner.
+    * The number of elements pointed to by `data`.
     */
-   bool is_owned;
-} LDKOpenChannel;
-
-
+   uintptr_t datalen;
+} LDKCVec_TransactionZ;
 
 /**
- * A funding_created message to be sent or received from a peer
+ * A tuple of 2 elements. See the individual fields for the types contained.
  */
-typedef struct MUST_USE_STRUCT LDKFundingCreated {
+typedef struct LDKC2Tuple_usizeTransactionZ {
    /**
-    * A pointer to the opaque Rust object.
-    * Nearly everywhere, inner must be non-null, however in places where
-    * the Rust equivalent takes an Option, it may be set to null to indicate None.
+    * The element at position 0
     */
-   LDKnativeFundingCreated *inner;
+   uintptr_t a;
    /**
-    * Indicates that this is the only struct which contains the same pointer.
-    * Rust functions which take ownership of an object provided via an argument require
-    * this to be true and invalidate the object pointed to by inner.
+    * The element at position 1
     */
-   bool is_owned;
-} LDKFundingCreated;
-
-
+   struct LDKTransaction b;
+} LDKC2Tuple_usizeTransactionZ;
 
 /**
- * A funding_signed message to be sent or received from a peer
+ * A dynamically-allocated array of crate::c_types::derived::C2Tuple_usizeTransactionZs of arbitrary size.
+ * This corresponds to std::vector in C++
  */
-typedef struct MUST_USE_STRUCT LDKFundingSigned {
+typedef struct LDKCVec_C2Tuple_usizeTransactionZZ {
    /**
-    * A pointer to the opaque Rust object.
-    * Nearly everywhere, inner must be non-null, however in places where
-    * the Rust equivalent takes an Option, it may be set to null to indicate None.
+    * The elements in the array.
+    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
     */
-   LDKnativeFundingSigned *inner;
+   struct LDKC2Tuple_usizeTransactionZ *data;
    /**
-    * Indicates that this is the only struct which contains the same pointer.
-    * Rust functions which take ownership of an object provided via an argument require
-    * this to be true and invalidate the object pointed to by inner.
+    * The number of elements pointed to by `data`.
     */
-   bool is_owned;
-} LDKFundingSigned;
-
-
+   uintptr_t datalen;
+} LDKCVec_C2Tuple_usizeTransactionZZ;
 
 /**
- * A funding_locked message to be sent or received from a peer
+ * A tuple of 2 elements. See the individual fields for the types contained.
  */
-typedef struct MUST_USE_STRUCT LDKFundingLocked {
+typedef struct LDKC2Tuple_u32TxOutZ {
    /**
-    * A pointer to the opaque Rust object.
-    * Nearly everywhere, inner must be non-null, however in places where
-    * the Rust equivalent takes an Option, it may be set to null to indicate None.
+    * The element at position 0
     */
-   LDKnativeFundingLocked *inner;
+   uint32_t a;
    /**
-    * Indicates that this is the only struct which contains the same pointer.
-    * Rust functions which take ownership of an object provided via an argument require
-    * this to be true and invalidate the object pointed to by inner.
+    * The element at position 1
     */
-   bool is_owned;
-} LDKFundingLocked;
-
-
+   struct LDKTxOut b;
+} LDKC2Tuple_u32TxOutZ;
 
 /**
- * An announcement_signatures message to be sent or received from a peer
+ * A dynamically-allocated array of crate::c_types::derived::C2Tuple_u32TxOutZs of arbitrary size.
+ * This corresponds to std::vector in C++
  */
-typedef struct MUST_USE_STRUCT LDKAnnouncementSignatures {
+typedef struct LDKCVec_C2Tuple_u32TxOutZZ {
    /**
-    * A pointer to the opaque Rust object.
-    * Nearly everywhere, inner must be non-null, however in places where
-    * the Rust equivalent takes an Option, it may be set to null to indicate None.
+    * The elements in the array.
+    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
     */
-   LDKnativeAnnouncementSignatures *inner;
+   struct LDKC2Tuple_u32TxOutZ *data;
    /**
-    * Indicates that this is the only struct which contains the same pointer.
-    * Rust functions which take ownership of an object provided via an argument require
-    * this to be true and invalidate the object pointed to by inner.
+    * The number of elements pointed to by `data`.
     */
-   bool is_owned;
-} LDKAnnouncementSignatures;
-
-
+   uintptr_t datalen;
+} LDKCVec_C2Tuple_u32TxOutZZ;
 
 /**
- * Struct used to return values from revoke_and_ack messages, containing a bunch of commitment
- * transaction updates if they were pending.
+ * A tuple of 2 elements. See the individual fields for the types contained.
  */
-typedef struct MUST_USE_STRUCT LDKCommitmentUpdate {
+typedef struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ {
    /**
-    * A pointer to the opaque Rust object.
-    * Nearly everywhere, inner must be non-null, however in places where
-    * the Rust equivalent takes an Option, it may be set to null to indicate None.
+    * The element at position 0
     */
-   LDKnativeCommitmentUpdate *inner;
+   struct LDKThirtyTwoBytes a;
    /**
-    * Indicates that this is the only struct which contains the same pointer.
-    * Rust functions which take ownership of an object provided via an argument require
-    * this to be true and invalidate the object pointed to by inner.
+    * The element at position 1
     */
-   bool is_owned;
-} LDKCommitmentUpdate;
-
-
+   struct LDKCVec_C2Tuple_u32TxOutZZ b;
+} LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ;
 
 /**
- * A revoke_and_ack message to be sent or received from a peer
+ * A dynamically-allocated array of crate::c_types::derived::C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZs of arbitrary size.
+ * This corresponds to std::vector in C++
  */
-typedef struct MUST_USE_STRUCT LDKRevokeAndACK {
+typedef struct LDKCVec_TransactionOutputsZ {
    /**
-    * A pointer to the opaque Rust object.
-    * Nearly everywhere, inner must be non-null, however in places where
-    * the Rust equivalent takes an Option, it may be set to null to indicate None.
+    * The elements in the array.
+    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
     */
-   LDKnativeRevokeAndACK *inner;
+   struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *data;
    /**
-    * Indicates that this is the only struct which contains the same pointer.
-    * Rust functions which take ownership of an object provided via an argument require
-    * this to be true and invalidate the object pointed to by inner.
+    * The number of elements pointed to by `data`.
     */
-   bool is_owned;
-} LDKRevokeAndACK;
-
-
+   uintptr_t datalen;
+} LDKCVec_TransactionOutputsZ;
 
 /**
- * A closing_signed message to be sent or received from a peer
+ * A dynamically-allocated array of crate::c_types::ThirtyTwoBytess of arbitrary size.
+ * This corresponds to std::vector in C++
  */
-typedef struct MUST_USE_STRUCT LDKClosingSigned {
+typedef struct LDKCVec_TxidZ {
    /**
-    * A pointer to the opaque Rust object.
-    * Nearly everywhere, inner must be non-null, however in places where
-    * the Rust equivalent takes an Option, it may be set to null to indicate None.
+    * The elements in the array.
+    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
     */
-   LDKnativeClosingSigned *inner;
+   struct LDKThirtyTwoBytes *data;
    /**
-    * Indicates that this is the only struct which contains the same pointer.
-    * Rust functions which take ownership of an object provided via an argument require
-    * this to be true and invalidate the object pointed to by inner.
+    * The number of elements pointed to by `data`.
     */
-   bool is_owned;
-} LDKClosingSigned;
-
-
+   uintptr_t datalen;
+} LDKCVec_TxidZ;
 
 /**
- * A shutdown message to be sent or received from a peer
+ * The contents of CResult_NoneChannelMonitorUpdateErrZ
  */
-typedef struct MUST_USE_STRUCT LDKShutdown {
+typedef union LDKCResult_NoneChannelMonitorUpdateErrZPtr {
    /**
-    * A pointer to the opaque Rust object.
-    * Nearly everywhere, inner must be non-null, however in places where
-    * the Rust equivalent takes an Option, it may be set to null to indicate None.
+    * Note that this value is always NULL, as there are no contents in the OK variant
     */
-   LDKnativeShutdown *inner;
+   void *result;
    /**
-    * Indicates that this is the only struct which contains the same pointer.
-    * Rust functions which take ownership of an object provided via an argument require
-    * this to be true and invalidate the object pointed to by inner.
+    * A pointer to the contents in the error state.
+    * Reading from this pointer when `result_ok` is set is undefined.
     */
-   bool is_owned;
-} LDKShutdown;
-
-
+   enum LDKChannelMonitorUpdateErr *err;
+} LDKCResult_NoneChannelMonitorUpdateErrZPtr;
 
 /**
- * A channel_reestablish message to be sent or received from a peer
+ * A CResult_NoneChannelMonitorUpdateErrZ represents the result of a fallible operation,
+ * containing a () on success and a crate::lightning::chain::channelmonitor::ChannelMonitorUpdateErr on failure.
+ * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct MUST_USE_STRUCT LDKChannelReestablish {
+typedef struct LDKCResult_NoneChannelMonitorUpdateErrZ {
    /**
-    * A pointer to the opaque Rust object.
-    * Nearly everywhere, inner must be non-null, however in places where
-    * the Rust equivalent takes an Option, it may be set to null to indicate None.
+    * The contents of this CResult_NoneChannelMonitorUpdateErrZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   LDKnativeChannelReestablish *inner;
+   union LDKCResult_NoneChannelMonitorUpdateErrZPtr contents;
    /**
-    * Indicates that this is the only struct which contains the same pointer.
-    * Rust functions which take ownership of an object provided via an argument require
-    * this to be true and invalidate the object pointed to by inner.
+    * Whether this CResult_NoneChannelMonitorUpdateErrZ represents a success state.
     */
-   bool is_owned;
-} LDKChannelReestablish;
-
-
+   bool result_ok;
+} LDKCResult_NoneChannelMonitorUpdateErrZ;
 
 /**
- * A channel_announcement message to be sent or received from a peer
+ * A tuple of 2 elements. See the individual fields for the types contained.
  */
-typedef struct MUST_USE_STRUCT LDKChannelAnnouncement {
+typedef struct LDKC2Tuple_SignatureCVec_SignatureZZ {
    /**
-    * A pointer to the opaque Rust object.
-    * Nearly everywhere, inner must be non-null, however in places where
-    * the Rust equivalent takes an Option, it may be set to null to indicate None.
+    * The element at position 0
     */
-   LDKnativeChannelAnnouncement *inner;
+   struct LDKSignature a;
    /**
-    * Indicates that this is the only struct which contains the same pointer.
-    * Rust functions which take ownership of an object provided via an argument require
-    * this to be true and invalidate the object pointed to by inner.
+    * The element at position 1
     */
-   bool is_owned;
-} LDKChannelAnnouncement;
-
-
+   struct LDKCVec_SignatureZ b;
+} LDKC2Tuple_SignatureCVec_SignatureZZ;
 
 /**
- * A channel_update message to be sent or received from a peer
+ * The contents of CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ
  */
-typedef struct MUST_USE_STRUCT LDKChannelUpdate {
+typedef union LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZPtr {
    /**
-    * A pointer to the opaque Rust object.
-    * Nearly everywhere, inner must be non-null, however in places where
-    * the Rust equivalent takes an Option, it may be set to null to indicate None.
+    * A pointer to the contents in the success state.
+    * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   LDKnativeChannelUpdate *inner;
+   struct LDKC2Tuple_SignatureCVec_SignatureZZ *result;
    /**
-    * Indicates that this is the only struct which contains the same pointer.
-    * Rust functions which take ownership of an object provided via an argument require
-    * this to be true and invalidate the object pointed to by inner.
+    * Note that this value is always NULL, as there are no contents in the Err variant
     */
-   bool is_owned;
-} LDKChannelUpdate;
+   void *err;
+} LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZPtr;
 
+/**
+ * A CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ represents the result of a fallible operation,
+ * containing a crate::c_types::derived::C2Tuple_SignatureCVec_SignatureZZ on success and a () on failure.
+ * `result_ok` indicates the overall state, and the contents are provided via `contents`.
+ */
+typedef struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ {
+   /**
+    * The contents of this CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
+    */
+   union LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZPtr contents;
+   /**
+    * Whether this CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ represents a success state.
+    */
+   bool result_ok;
+} LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ;
 
+/**
+ * The contents of CResult_SignatureNoneZ
+ */
+typedef union LDKCResult_SignatureNoneZPtr {
+   /**
+    * A pointer to the contents in the success state.
+    * Reading from this pointer when `result_ok` is not set is undefined.
+    */
+   struct LDKSignature *result;
+   /**
+    * Note that this value is always NULL, as there are no contents in the Err variant
+    */
+   void *err;
+} LDKCResult_SignatureNoneZPtr;
 
 /**
- * A node_announcement message to be sent or received from a peer
+ * A CResult_SignatureNoneZ represents the result of a fallible operation,
+ * containing a crate::c_types::Signature on success and a () on failure.
+ * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct MUST_USE_STRUCT LDKNodeAnnouncement {
+typedef struct LDKCResult_SignatureNoneZ {
    /**
-    * A pointer to the opaque Rust object.
-    * Nearly everywhere, inner must be non-null, however in places where
-    * the Rust equivalent takes an Option, it may be set to null to indicate None.
+    * The contents of this CResult_SignatureNoneZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   LDKnativeNodeAnnouncement *inner;
+   union LDKCResult_SignatureNoneZPtr contents;
    /**
-    * Indicates that this is the only struct which contains the same pointer.
-    * Rust functions which take ownership of an object provided via an argument require
-    * this to be true and invalidate the object pointed to by inner.
+    * Whether this CResult_SignatureNoneZ represents a success state.
     */
-   bool is_owned;
-} LDKNodeAnnouncement;
+   bool result_ok;
+} LDKCResult_SignatureNoneZ;
 
 
 
 /**
- * An error message to be sent or received from a peer
+ * The unsigned part of a channel_announcement
  */
-typedef struct MUST_USE_STRUCT LDKErrorMessage {
+typedef struct MUST_USE_STRUCT LDKUnsignedChannelAnnouncement {
    /**
     * A pointer to the opaque Rust object.
     * Nearly everywhere, inner must be non-null, however in places where
     * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   LDKnativeErrorMessage *inner;
+   LDKnativeUnsignedChannelAnnouncement *inner;
    /**
     * Indicates that this is the only struct which contains the same pointer.
     * Rust functions which take ownership of an object provided via an argument require
     * this to be true and invalidate the object pointed to by inner.
     */
    bool is_owned;
-} LDKErrorMessage;
+} LDKUnsignedChannelAnnouncement;
 
 /**
- * Used to put an error message in a LightningError
+ * A trait to sign lightning channel transactions as described in BOLT 3.
+ *
+ * Signing services could be implemented on a hardware wallet. In this case,
+ * the current Sign would be a front-end on top of a communication
+ * channel connected to your secure device and lightning key material wouldn't
+ * reside on a hot server. Nevertheless, a this deployment would still need
+ * to trust the ChannelManager to avoid loss of funds as this latest component
+ * could ask to sign commitment transaction with HTLCs paying to attacker pubkeys.
+ *
+ * A more secure iteration would be to use hashlock (or payment points) to pair
+ * invoice/incoming HTLCs with outgoing HTLCs to implement a no-trust-ChannelManager
+ * at the price of more state and computation on the hardware wallet side. In the future,
+ * we are looking forward to design such interface.
+ *
+ * In any case, ChannelMonitor or fallback watchtowers are always going to be trusted
+ * to act, as liveness and breach reply correctness are always going to be hard requirements
+ * of LN security model, orthogonal of key management issues.
  */
-typedef enum LDKErrorAction_Tag {
+typedef struct LDKBaseSign {
    /**
-    * The peer took some action which made us think they were useless. Disconnect them.
+    * An opaque pointer which is passed to your function implementations as an argument.
+    * This has no meaning in the LDK, and can be NULL or any other value.
     */
-   LDKErrorAction_DisconnectPeer,
+   void *this_arg;
    /**
-    * The peer did something harmless that we weren't able to process, just log and ignore
+    * Gets the per-commitment point for a specific commitment number
+    *
+    * Note that the commitment number starts at (1 << 48) - 1 and counts backwards.
     */
-   LDKErrorAction_IgnoreError,
+   struct LDKPublicKey (*get_per_commitment_point)(const void *this_arg, uint64_t idx);
    /**
-    * The peer did something incorrect. Tell them.
+    * Gets the commitment secret for a specific commitment number as part of the revocation process
+    *
+    * An external signer implementation should error here if the commitment was already signed
+    * and should refuse to sign it in the future.
+    *
+    * May be called more than once for the same index.
+    *
+    * Note that the commitment number starts at (1 << 48) - 1 and counts backwards.
     */
-   LDKErrorAction_SendErrorMessage,
+   struct LDKThirtyTwoBytes (*release_commitment_secret)(const void *this_arg, uint64_t idx);
    /**
-    * Must be last for serialization purposes
+    * Gets the holder's channel public keys and basepoints
     */
-   LDKErrorAction_Sentinel,
-} LDKErrorAction_Tag;
-
-typedef struct LDKErrorAction_LDKDisconnectPeer_Body {
+   struct LDKChannelPublicKeys pubkeys;
    /**
-    * An error message which we should make an effort to send before we disconnect.
+    * Fill in the pubkeys field as a reference to it will be given to Rust after this returns
+    * Note that this takes a pointer to this object, not the this_ptr like other methods do
+    * This function pointer may be NULL if pubkeys is filled in when this object is created and never needs updating.
     */
-   struct LDKErrorMessage msg;
-} LDKErrorAction_LDKDisconnectPeer_Body;
-
-typedef struct LDKErrorAction_LDKSendErrorMessage_Body {
+   void (*set_pubkeys)(const struct LDKBaseSign*NONNULL_PTR );
    /**
-    * The message to send.
+    * Gets an arbitrary identifier describing the set of keys which are provided back to you in
+    * some SpendableOutputDescriptor types. This should be sufficient to identify this
+    * Sign object uniquely and lookup or re-derive its keys.
     */
-   struct LDKErrorMessage msg;
-} LDKErrorAction_LDKSendErrorMessage_Body;
-
-typedef struct MUST_USE_STRUCT LDKErrorAction {
-   LDKErrorAction_Tag tag;
-   union {
-      LDKErrorAction_LDKDisconnectPeer_Body disconnect_peer;
-      LDKErrorAction_LDKSendErrorMessage_Body send_error_message;
-   };
-} LDKErrorAction;
-
-/**
- * The information we received from a peer along the route of a payment we originated. This is
- * returned by ChannelMessageHandler::handle_update_fail_htlc to be passed into
- * RoutingMessageHandler::handle_htlc_fail_channel_update to update our network map.
- */
-typedef enum LDKHTLCFailChannelUpdate_Tag {
+   struct LDKThirtyTwoBytes (*channel_keys_id)(const void *this_arg);
    /**
-    * We received an error which included a full ChannelUpdate message.
+    * Create a signature for a counterparty's commitment transaction and associated HTLC transactions.
+    *
+    * Note that if signing fails or is rejected, the channel will be force-closed.
     */
-   LDKHTLCFailChannelUpdate_ChannelUpdateMessage,
+   struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ (*sign_counterparty_commitment)(const void *this_arg, const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx);
    /**
-    * We received an error which indicated only that a channel has been closed
+    * Create a signatures for a holder's commitment transaction and its claiming HTLC transactions.
+    * This will only ever be called with a non-revoked commitment_tx.  This will be called with the
+    * latest commitment_tx when we initiate a force-close.
+    * This will be called with the previous latest, just to get claiming HTLC signatures, if we are
+    * reacting to a ChannelMonitor replica that decided to broadcast before it had been updated to
+    * the latest.
+    * This may be called multiple times for the same transaction.
+    *
+    * An external signer implementation should check that the commitment has not been revoked.
+    *
+    * May return Err if key derivation fails.  Callers, such as ChannelMonitor, will panic in such a case.
     */
-   LDKHTLCFailChannelUpdate_ChannelClosed,
+   struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ (*sign_holder_commitment_and_htlcs)(const void *this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx);
    /**
-    * We received an error which indicated only that a node has failed
+    * Create a signature for the given input in a transaction spending an HTLC or commitment
+    * transaction output when our counterparty broadcasts an old state.
+    *
+    * A justice transaction may claim multiples outputs at the same time if timelocks are
+    * similar, but only a signature for the input at index `input` should be signed for here.
+    * It may be called multiples time for same output(s) if a fee-bump is needed with regards
+    * to an upcoming timelock expiration.
+    *
+    * Amount is value of the output spent by this input, committed to in the BIP 143 signature.
+    *
+    * per_commitment_key is revocation secret which was provided by our counterparty when they
+    * revoked the state which they eventually broadcast. It's not a _holder_ secret key and does
+    * not allow the spending of any funds by itself (you need our holder revocation_secret to do
+    * so).
+    *
+    * htlc holds HTLC elements (hash, timelock) if the output being spent is a HTLC output, thus
+    * changing the format of the witness script (which is committed to in the BIP 143
+    * signatures).
     */
-   LDKHTLCFailChannelUpdate_NodeFailure,
+   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);
    /**
-    * Must be last for serialization purposes
+    * Create a signature for a claiming transaction for a HTLC output on a counterparty's commitment
+    * transaction, either offered or received.
+    *
+    * Such a transaction may claim multiples offered outputs at same time if we know the
+    * preimage for each when we create it, but only the input at index `input` should be
+    * signed for here. It may be called multiple times for same output(s) if a fee-bump is
+    * needed with regards to an upcoming timelock expiration.
+    *
+    * Witness_script is either a offered or received script as defined in BOLT3 for HTLC
+    * outputs.
+    *
+    * Amount is value of the output spent by this input, committed to in the BIP 143 signature.
+    *
+    * Per_commitment_point is the dynamic point corresponding to the channel state
+    * detected onchain. It has been generated by our counterparty and is used to derive
+    * channel state keys, which are then included in the witness script and committed to in the
+    * BIP 143 signature.
     */
-   LDKHTLCFailChannelUpdate_Sentinel,
-} LDKHTLCFailChannelUpdate_Tag;
-
-typedef struct LDKHTLCFailChannelUpdate_LDKChannelUpdateMessage_Body {
+   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);
    /**
-    * The unwrapped message we received
+    * Create a signature for a (proposed) closing transaction.
+    *
+    * Note that, due to rounding, there may be one \"missing\" satoshi, and either party may have
+    * chosen to forgo their output as dust.
     */
-   struct LDKChannelUpdate msg;
-} LDKHTLCFailChannelUpdate_LDKChannelUpdateMessage_Body;
-
-typedef struct LDKHTLCFailChannelUpdate_LDKChannelClosed_Body {
+   struct LDKCResult_SignatureNoneZ (*sign_closing_transaction)(const void *this_arg, struct LDKTransaction closing_tx);
    /**
-    * The short_channel_id which has now closed.
+    * Signs a channel announcement message with our funding key, proving it comes from one
+    * of the channel participants.
+    *
+    * Note that if this fails or is rejected, the channel will not be publicly announced and
+    * our counterparty may (though likely will not) close the channel on us for violating the
+    * protocol.
     */
-   uint64_t short_channel_id;
+   struct LDKCResult_SignatureNoneZ (*sign_channel_announcement)(const void *this_arg, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg);
    /**
-    * when this true, this channel should be permanently removed from the
-    * consideration. Otherwise, this channel can be restored as new channel_update is received
+    * Set the counterparty static channel data, including basepoints,
+    * counterparty_selected/holder_selected_contest_delay and funding outpoint.
+    * This is done as soon as the funding outpoint is known.  Since these are static channel data,
+    * they MUST NOT be allowed to change to different values once set.
+    *
+    * channel_parameters.is_populated() MUST be true.
+    *
+    * We bind holder_selected_contest_delay late here for API convenience.
+    *
+    * Will be called before any signatures are applied.
     */
-   bool is_permanent;
-} LDKHTLCFailChannelUpdate_LDKChannelClosed_Body;
+   void (*ready_channel)(void *this_arg, const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters);
+   /**
+    * Frees any resources associated with this object given its this_arg pointer.
+    * Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
+    */
+   void (*free)(void *this_arg);
+} LDKBaseSign;
 
-typedef struct LDKHTLCFailChannelUpdate_LDKNodeFailure_Body {
+/**
+ * A cloneable signer.
+ *
+ * Although we require signers to be cloneable, it may be useful for developers to be able to use
+ * signers in an un-sized way, for example as `dyn BaseSign`. Therefore we separate the Clone trait,
+ * which implies Sized, into this derived trait.
+ */
+typedef struct LDKSign {
    /**
-    * The node_id that has failed.
+    * An opaque pointer which is passed to your function implementations as an argument.
+    * This has no meaning in the LDK, and can be NULL or any other value.
     */
-   struct LDKPublicKey node_id;
+   void *this_arg;
    /**
-    * when this true, node should be permanently removed from the
-    * consideration. Otherwise, the channels connected to this node can be
-    * restored as new channel_update is received
+    * Implementation of BaseSign for this object.
     */
-   bool is_permanent;
-} LDKHTLCFailChannelUpdate_LDKNodeFailure_Body;
-
-typedef struct MUST_USE_STRUCT LDKHTLCFailChannelUpdate {
-   LDKHTLCFailChannelUpdate_Tag tag;
-   union {
-      LDKHTLCFailChannelUpdate_LDKChannelUpdateMessage_Body channel_update_message;
-      LDKHTLCFailChannelUpdate_LDKChannelClosed_Body channel_closed;
-      LDKHTLCFailChannelUpdate_LDKNodeFailure_Body node_failure;
-   };
-} LDKHTLCFailChannelUpdate;
+   struct LDKBaseSign BaseSign;
+   /**
+    * Creates a copy of the BaseSign, for a copy of this Sign.
+    * Because BaseSign doesn't natively support copying itself, you have to provide a full copy implementation here.
+    */
+   struct LDKBaseSign (*BaseSign_clone)(const struct LDKBaseSign *NONNULL_PTR orig_BaseSign);
+   /**
+    * Serialize the object into a byte array
+    */
+   struct LDKCVec_u8Z (*write)(const void *this_arg);
+   /**
+    * Creates a copy of the object pointed to by this_arg, for a copy of this Sign.
+    * Note that the ultimate copy of the Sign will have all function pointers the same as the original.
+    * May be NULL if no action needs to be taken, the this_arg pointer will be copied into the new Sign.
+    */
+   void *(*clone)(const void *this_arg);
+   /**
+    * Frees any resources associated with this object given its this_arg pointer.
+    * Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
+    */
+   void (*free)(void *this_arg);
+} LDKSign;
 
 
 
 /**
- * A query_channel_range message is used to query a peer for channel
- * UTXOs in a range of blocks. The recipient of a query makes a best
- * effort to reply to the query using one or more reply_channel_range
- * messages.
+ * A ChannelMonitor handles chain events (blocks connected and disconnected) and generates
+ * on-chain transactions to ensure no loss of funds occurs.
+ *
+ * You MUST ensure that no ChannelMonitors for a given channel anywhere contain out-of-date
+ * information and are actively monitoring the chain.
+ *
+ * Pending Events or updated HTLCs which have not yet been read out by
+ * get_and_clear_pending_monitor_events or get_and_clear_pending_events are serialized to disk and
+ * reloaded at deserialize-time. Thus, you must ensure that, when handling events, all events
+ * gotten are fully handled before re-serializing the new state.
+ *
+ * Note that the deserializer is only implemented for (BlockHash, ChannelMonitor), which
+ * tells you the last block hash which was block_connect()ed. You MUST rescan any blocks along
+ * the \"reorg path\" (ie disconnecting blocks until you find a common ancestor from both the
+ * returned block hash and the the current chain and then reconnecting blocks to get to the
+ * best chain) upon deserializing the object!
  */
-typedef struct MUST_USE_STRUCT LDKQueryChannelRange {
+typedef struct MUST_USE_STRUCT LDKChannelMonitor {
    /**
     * A pointer to the opaque Rust object.
     * Nearly everywhere, inner must be non-null, however in places where
     * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   LDKnativeQueryChannelRange *inner;
+   LDKnativeChannelMonitor *inner;
    /**
     * Indicates that this is the only struct which contains the same pointer.
     * Rust functions which take ownership of an object provided via an argument require
     * this to be true and invalidate the object pointed to by inner.
     */
    bool is_owned;
-} LDKQueryChannelRange;
+} LDKChannelMonitor;
 
+/**
+ * A tuple of 2 elements. See the individual fields for the types contained.
+ */
+typedef struct LDKC2Tuple_BlockHashChannelMonitorZ {
+   /**
+    * The element at position 0
+    */
+   struct LDKThirtyTwoBytes a;
+   /**
+    * The element at position 1
+    */
+   struct LDKChannelMonitor b;
+} LDKC2Tuple_BlockHashChannelMonitorZ;
 
+/**
+ * The contents of CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ
+ */
+typedef union LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZPtr {
+   /**
+    * A pointer to the contents in the success state.
+    * Reading from this pointer when `result_ok` is not set is undefined.
+    */
+   struct LDKC2Tuple_BlockHashChannelMonitorZ *result;
+   /**
+    * A pointer to the contents in the error state.
+    * Reading from this pointer when `result_ok` is set is undefined.
+    */
+   struct LDKDecodeError *err;
+} LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZPtr;
 
 /**
- * A query_short_channel_ids message is used to query a peer for
- * routing gossip messages related to one or more short_channel_ids.
- * The query recipient will reply with the latest, if available,
- * channel_announcement, channel_update and node_announcement messages
- * it maintains for the requested short_channel_ids followed by a
- * reply_short_channel_ids_end message. The short_channel_ids sent in
- * this query are encoded. We only support encoding_type=0 uncompressed
- * serialization and do not support encoding_type=1 zlib serialization.
+ * A CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::c_types::derived::C2Tuple_BlockHashChannelMonitorZ on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct MUST_USE_STRUCT LDKQueryShortChannelIds {
+typedef struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ {
    /**
-    * A pointer to the opaque Rust object.
-    * Nearly everywhere, inner must be non-null, however in places where
-    * the Rust equivalent takes an Option, it may be set to null to indicate None.
+    * The contents of this CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   LDKnativeQueryShortChannelIds *inner;
+   union LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZPtr contents;
    /**
-    * Indicates that this is the only struct which contains the same pointer.
-    * Rust functions which take ownership of an object provided via an argument require
-    * this to be true and invalidate the object pointed to by inner.
+    * Whether this CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ represents a success state.
     */
-   bool is_owned;
-} LDKQueryShortChannelIds;
+   bool result_ok;
+} LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ;
 
 
 
 /**
- * A reply_channel_range message is a reply to a query_channel_range
- * message. Multiple reply_channel_range messages can be sent in reply
- * to a single query_channel_range message. The query recipient makes a
- * best effort to respond based on their local network view which may
- * not be a perfect view of the network. The short_channel_ids in the
- * reply are encoded. We only support encoding_type=0 uncompressed
- * serialization and do not support encoding_type=1 zlib serialization.
+ * A hop in a route
  */
-typedef struct MUST_USE_STRUCT LDKReplyChannelRange {
+typedef struct MUST_USE_STRUCT LDKRouteHop {
    /**
     * A pointer to the opaque Rust object.
     * Nearly everywhere, inner must be non-null, however in places where
     * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   LDKnativeReplyChannelRange *inner;
+   LDKnativeRouteHop *inner;
    /**
     * Indicates that this is the only struct which contains the same pointer.
     * Rust functions which take ownership of an object provided via an argument require
     * this to be true and invalidate the object pointed to by inner.
     */
    bool is_owned;
-} LDKReplyChannelRange;
+} LDKRouteHop;
 
 /**
- * An event generated by ChannelManager which indicates a message should be sent to a peer (or
- * broadcast to most peers).
- * These events are handled by PeerManager::process_events if you are using a PeerManager.
+ * A dynamically-allocated array of crate::lightning::routing::router::RouteHops of arbitrary size.
+ * This corresponds to std::vector in C++
  */
-typedef enum LDKMessageSendEvent_Tag {
-   /**
-    * Used to indicate that we've accepted a channel open and should send the accept_channel
-    * message provided to the given peer.
-    */
-   LDKMessageSendEvent_SendAcceptChannel,
-   /**
-    * Used to indicate that we've initiated a channel open and should send the open_channel
-    * message provided to the given peer.
-    */
-   LDKMessageSendEvent_SendOpenChannel,
+typedef struct LDKCVec_RouteHopZ {
    /**
-    * Used to indicate that a funding_created message should be sent to the peer with the given node_id.
+    * The elements in the array.
+    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
     */
-   LDKMessageSendEvent_SendFundingCreated,
+   struct LDKRouteHop *data;
    /**
-    * Used to indicate that a funding_signed message should be sent to the peer with the given node_id.
+    * The number of elements pointed to by `data`.
     */
-   LDKMessageSendEvent_SendFundingSigned,
+   uintptr_t datalen;
+} LDKCVec_RouteHopZ;
+
+/**
+ * A dynamically-allocated array of crate::c_types::derived::CVec_RouteHopZs of arbitrary size.
+ * This corresponds to std::vector in C++
+ */
+typedef struct LDKCVec_CVec_RouteHopZZ {
    /**
-    * Used to indicate that a funding_locked message should be sent to the peer with the given node_id.
+    * The elements in the array.
+    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
     */
-   LDKMessageSendEvent_SendFundingLocked,
+   struct LDKCVec_RouteHopZ *data;
    /**
-    * Used to indicate that an announcement_signatures message should be sent to the peer with the given node_id.
+    * The number of elements pointed to by `data`.
     */
-   LDKMessageSendEvent_SendAnnouncementSignatures,
+   uintptr_t datalen;
+} LDKCVec_CVec_RouteHopZZ;
+
+
+
+/**
+ * A route directs a payment from the sender (us) to the recipient. If the recipient supports MPP,
+ * it can take multiple paths. Each path is composed of one or more hops through the network.
+ */
+typedef struct MUST_USE_STRUCT LDKRoute {
    /**
-    * Used to indicate that a series of HTLC update messages, as well as a commitment_signed
-    * message should be sent to the peer with the given node_id.
+    * A pointer to the opaque Rust object.
+    * Nearly everywhere, inner must be non-null, however in places where
+    * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   LDKMessageSendEvent_UpdateHTLCs,
+   LDKnativeRoute *inner;
    /**
-    * Used to indicate that a revoke_and_ack message should be sent to the peer with the given node_id.
+    * Indicates that this is the only struct which contains the same pointer.
+    * Rust functions which take ownership of an object provided via an argument require
+    * this to be true and invalidate the object pointed to by inner.
     */
-   LDKMessageSendEvent_SendRevokeAndACK,
+   bool is_owned;
+} LDKRoute;
+
+/**
+ * The contents of CResult_RouteDecodeErrorZ
+ */
+typedef union LDKCResult_RouteDecodeErrorZPtr {
    /**
-    * Used to indicate that a closing_signed message should be sent to the peer with the given node_id.
+    * A pointer to the contents in the success state.
+    * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   LDKMessageSendEvent_SendClosingSigned,
+   struct LDKRoute *result;
    /**
-    * Used to indicate that a shutdown message should be sent to the peer with the given node_id.
+    * A pointer to the contents in the error state.
+    * Reading from this pointer when `result_ok` is set is undefined.
     */
-   LDKMessageSendEvent_SendShutdown,
+   struct LDKDecodeError *err;
+} LDKCResult_RouteDecodeErrorZPtr;
+
+/**
+ * A CResult_RouteDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::routing::router::Route on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * `result_ok` indicates the overall state, and the contents are provided via `contents`.
+ */
+typedef struct LDKCResult_RouteDecodeErrorZ {
    /**
-    * Used to indicate that a channel_reestablish message should be sent to the peer with the given node_id.
+    * The contents of this CResult_RouteDecodeErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   LDKMessageSendEvent_SendChannelReestablish,
+   union LDKCResult_RouteDecodeErrorZPtr contents;
    /**
-    * Used to indicate that a channel_announcement and channel_update should be broadcast to all
-    * peers (except the peer with node_id either msg.contents.node_id_1 or msg.contents.node_id_2).
-    *
-    * Note that after doing so, you very likely (unless you did so very recently) want to call
-    * ChannelManager::broadcast_node_announcement to trigger a BroadcastNodeAnnouncement event.
-    * This ensures that any nodes which see our channel_announcement also have a relevant
-    * node_announcement, including relevant feature flags which may be important for routing
-    * through or to us.
+    * Whether this CResult_RouteDecodeErrorZ represents a success state.
     */
-   LDKMessageSendEvent_BroadcastChannelAnnouncement,
+   bool result_ok;
+} LDKCResult_RouteDecodeErrorZ;
+
+
+
+/**
+ * Details of a channel, as returned by ChannelManager::list_channels and ChannelManager::list_usable_channels
+ */
+typedef struct MUST_USE_STRUCT LDKChannelDetails {
    /**
-    * Used to indicate that a node_announcement should be broadcast to all peers.
+    * A pointer to the opaque Rust object.
+    * Nearly everywhere, inner must be non-null, however in places where
+    * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   LDKMessageSendEvent_BroadcastNodeAnnouncement,
+   LDKnativeChannelDetails *inner;
    /**
-    * Used to indicate that a channel_update should be broadcast to all peers.
+    * Indicates that this is the only struct which contains the same pointer.
+    * Rust functions which take ownership of an object provided via an argument require
+    * this to be true and invalidate the object pointed to by inner.
     */
-   LDKMessageSendEvent_BroadcastChannelUpdate,
+   bool is_owned;
+} LDKChannelDetails;
+
+/**
+ * A dynamically-allocated array of crate::lightning::ln::channelmanager::ChannelDetailss of arbitrary size.
+ * This corresponds to std::vector in C++
+ */
+typedef struct LDKCVec_ChannelDetailsZ {
    /**
-    * Broadcast an error downstream to be handled
+    * The elements in the array.
+    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
     */
-   LDKMessageSendEvent_HandleError,
+   struct LDKChannelDetails *data;
    /**
-    * When a payment fails we may receive updates back from the hop where it failed. In such
-    * cases this event is generated so that we can inform the network graph of this information.
+    * The number of elements pointed to by `data`.
     */
-   LDKMessageSendEvent_PaymentFailureNetworkUpdate,
+   uintptr_t datalen;
+} LDKCVec_ChannelDetailsZ;
+
+
+
+/**
+ * An Err type for failure to process messages.
+ */
+typedef struct MUST_USE_STRUCT LDKLightningError {
    /**
-    * Query a peer for channels with funding transaction UTXOs in a block range.
+    * A pointer to the opaque Rust object.
+    * Nearly everywhere, inner must be non-null, however in places where
+    * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   LDKMessageSendEvent_SendChannelRangeQuery,
+   LDKnativeLightningError *inner;
    /**
-    * Request routing gossip messages from a peer for a list of channels identified by
-    * their short_channel_ids.
+    * Indicates that this is the only struct which contains the same pointer.
+    * Rust functions which take ownership of an object provided via an argument require
+    * this to be true and invalidate the object pointed to by inner.
     */
-   LDKMessageSendEvent_SendShortIdsQuery,
+   bool is_owned;
+} LDKLightningError;
+
+/**
+ * The contents of CResult_RouteLightningErrorZ
+ */
+typedef union LDKCResult_RouteLightningErrorZPtr {
    /**
-    * Sends a reply to a channel range query. This may be one of several SendReplyChannelRange events
-    * emitted during processing of the query.
+    * A pointer to the contents in the success state.
+    * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   LDKMessageSendEvent_SendReplyChannelRange,
+   struct LDKRoute *result;
    /**
-    * Must be last for serialization purposes
+    * A pointer to the contents in the error state.
+    * Reading from this pointer when `result_ok` is set is undefined.
     */
-   LDKMessageSendEvent_Sentinel,
-} LDKMessageSendEvent_Tag;
+   struct LDKLightningError *err;
+} LDKCResult_RouteLightningErrorZPtr;
 
-typedef struct LDKMessageSendEvent_LDKSendAcceptChannel_Body {
+/**
+ * A CResult_RouteLightningErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::routing::router::Route on success and a crate::lightning::ln::msgs::LightningError on failure.
+ * `result_ok` indicates the overall state, and the contents are provided via `contents`.
+ */
+typedef struct LDKCResult_RouteLightningErrorZ {
    /**
-    * The node_id of the node which should receive this message
+    * The contents of this CResult_RouteLightningErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   struct LDKPublicKey node_id;
+   union LDKCResult_RouteLightningErrorZPtr contents;
    /**
-    * The message which should be sent.
+    * Whether this CResult_RouteLightningErrorZ represents a success state.
     */
-   struct LDKAcceptChannel msg;
-} LDKMessageSendEvent_LDKSendAcceptChannel_Body;
+   bool result_ok;
+} LDKCResult_RouteLightningErrorZ;
 
-typedef struct LDKMessageSendEvent_LDKSendOpenChannel_Body {
+
+
+/**
+ * An accept_channel message to be sent or received from a peer
+ */
+typedef struct MUST_USE_STRUCT LDKAcceptChannel {
    /**
-    * The node_id of the node which should receive this message
+    * A pointer to the opaque Rust object.
+    * Nearly everywhere, inner must be non-null, however in places where
+    * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   struct LDKPublicKey node_id;
+   LDKnativeAcceptChannel *inner;
    /**
-    * The message which should be sent.
+    * Indicates that this is the only struct which contains the same pointer.
+    * Rust functions which take ownership of an object provided via an argument require
+    * this to be true and invalidate the object pointed to by inner.
     */
-   struct LDKOpenChannel msg;
-} LDKMessageSendEvent_LDKSendOpenChannel_Body;
+   bool is_owned;
+} LDKAcceptChannel;
 
-typedef struct LDKMessageSendEvent_LDKSendFundingCreated_Body {
+
+
+/**
+ * An open_channel message to be sent or received from a peer
+ */
+typedef struct MUST_USE_STRUCT LDKOpenChannel {
    /**
-    * The node_id of the node which should receive this message
+    * A pointer to the opaque Rust object.
+    * Nearly everywhere, inner must be non-null, however in places where
+    * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   struct LDKPublicKey node_id;
+   LDKnativeOpenChannel *inner;
    /**
-    * The message which should be sent.
+    * Indicates that this is the only struct which contains the same pointer.
+    * Rust functions which take ownership of an object provided via an argument require
+    * this to be true and invalidate the object pointed to by inner.
     */
-   struct LDKFundingCreated msg;
-} LDKMessageSendEvent_LDKSendFundingCreated_Body;
+   bool is_owned;
+} LDKOpenChannel;
 
-typedef struct LDKMessageSendEvent_LDKSendFundingSigned_Body {
+
+
+/**
+ * A funding_created message to be sent or received from a peer
+ */
+typedef struct MUST_USE_STRUCT LDKFundingCreated {
    /**
-    * The node_id of the node which should receive this message
+    * A pointer to the opaque Rust object.
+    * Nearly everywhere, inner must be non-null, however in places where
+    * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   struct LDKPublicKey node_id;
+   LDKnativeFundingCreated *inner;
    /**
-    * The message which should be sent.
+    * Indicates that this is the only struct which contains the same pointer.
+    * Rust functions which take ownership of an object provided via an argument require
+    * this to be true and invalidate the object pointed to by inner.
     */
-   struct LDKFundingSigned msg;
-} LDKMessageSendEvent_LDKSendFundingSigned_Body;
+   bool is_owned;
+} LDKFundingCreated;
 
-typedef struct LDKMessageSendEvent_LDKSendFundingLocked_Body {
+
+
+/**
+ * A funding_signed message to be sent or received from a peer
+ */
+typedef struct MUST_USE_STRUCT LDKFundingSigned {
    /**
-    * The node_id of the node which should receive these message(s)
+    * A pointer to the opaque Rust object.
+    * Nearly everywhere, inner must be non-null, however in places where
+    * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   struct LDKPublicKey node_id;
+   LDKnativeFundingSigned *inner;
    /**
-    * The funding_locked message which should be sent.
+    * Indicates that this is the only struct which contains the same pointer.
+    * Rust functions which take ownership of an object provided via an argument require
+    * this to be true and invalidate the object pointed to by inner.
     */
-   struct LDKFundingLocked msg;
-} LDKMessageSendEvent_LDKSendFundingLocked_Body;
+   bool is_owned;
+} LDKFundingSigned;
 
-typedef struct LDKMessageSendEvent_LDKSendAnnouncementSignatures_Body {
+
+
+/**
+ * A funding_locked message to be sent or received from a peer
+ */
+typedef struct MUST_USE_STRUCT LDKFundingLocked {
    /**
-    * The node_id of the node which should receive these message(s)
+    * A pointer to the opaque Rust object.
+    * Nearly everywhere, inner must be non-null, however in places where
+    * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   struct LDKPublicKey node_id;
+   LDKnativeFundingLocked *inner;
    /**
-    * The announcement_signatures message which should be sent.
+    * Indicates that this is the only struct which contains the same pointer.
+    * Rust functions which take ownership of an object provided via an argument require
+    * this to be true and invalidate the object pointed to by inner.
     */
-   struct LDKAnnouncementSignatures msg;
-} LDKMessageSendEvent_LDKSendAnnouncementSignatures_Body;
+   bool is_owned;
+} LDKFundingLocked;
 
-typedef struct LDKMessageSendEvent_LDKUpdateHTLCs_Body {
+
+
+/**
+ * An announcement_signatures message to be sent or received from a peer
+ */
+typedef struct MUST_USE_STRUCT LDKAnnouncementSignatures {
    /**
-    * The node_id of the node which should receive these message(s)
+    * A pointer to the opaque Rust object.
+    * Nearly everywhere, inner must be non-null, however in places where
+    * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   struct LDKPublicKey node_id;
+   LDKnativeAnnouncementSignatures *inner;
    /**
-    * The update messages which should be sent. ALL messages in the struct should be sent!
+    * Indicates that this is the only struct which contains the same pointer.
+    * Rust functions which take ownership of an object provided via an argument require
+    * this to be true and invalidate the object pointed to by inner.
     */
-   struct LDKCommitmentUpdate updates;
-} LDKMessageSendEvent_LDKUpdateHTLCs_Body;
+   bool is_owned;
+} LDKAnnouncementSignatures;
 
-typedef struct LDKMessageSendEvent_LDKSendRevokeAndACK_Body {
+
+
+/**
+ * Struct used to return values from revoke_and_ack messages, containing a bunch of commitment
+ * transaction updates if they were pending.
+ */
+typedef struct MUST_USE_STRUCT LDKCommitmentUpdate {
    /**
-    * The node_id of the node which should receive this message
+    * A pointer to the opaque Rust object.
+    * Nearly everywhere, inner must be non-null, however in places where
+    * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   struct LDKPublicKey node_id;
+   LDKnativeCommitmentUpdate *inner;
    /**
-    * The message which should be sent.
+    * Indicates that this is the only struct which contains the same pointer.
+    * Rust functions which take ownership of an object provided via an argument require
+    * this to be true and invalidate the object pointed to by inner.
     */
-   struct LDKRevokeAndACK msg;
-} LDKMessageSendEvent_LDKSendRevokeAndACK_Body;
+   bool is_owned;
+} LDKCommitmentUpdate;
 
-typedef struct LDKMessageSendEvent_LDKSendClosingSigned_Body {
+
+
+/**
+ * A revoke_and_ack message to be sent or received from a peer
+ */
+typedef struct MUST_USE_STRUCT LDKRevokeAndACK {
    /**
-    * The node_id of the node which should receive this message
+    * A pointer to the opaque Rust object.
+    * Nearly everywhere, inner must be non-null, however in places where
+    * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   struct LDKPublicKey node_id;
+   LDKnativeRevokeAndACK *inner;
    /**
-    * The message which should be sent.
+    * Indicates that this is the only struct which contains the same pointer.
+    * Rust functions which take ownership of an object provided via an argument require
+    * this to be true and invalidate the object pointed to by inner.
     */
-   struct LDKClosingSigned msg;
-} LDKMessageSendEvent_LDKSendClosingSigned_Body;
+   bool is_owned;
+} LDKRevokeAndACK;
 
-typedef struct LDKMessageSendEvent_LDKSendShutdown_Body {
+
+
+/**
+ * A closing_signed message to be sent or received from a peer
+ */
+typedef struct MUST_USE_STRUCT LDKClosingSigned {
    /**
-    * The node_id of the node which should receive this message
+    * A pointer to the opaque Rust object.
+    * Nearly everywhere, inner must be non-null, however in places where
+    * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   struct LDKPublicKey node_id;
+   LDKnativeClosingSigned *inner;
    /**
-    * The message which should be sent.
+    * Indicates that this is the only struct which contains the same pointer.
+    * Rust functions which take ownership of an object provided via an argument require
+    * this to be true and invalidate the object pointed to by inner.
     */
-   struct LDKShutdown msg;
-} LDKMessageSendEvent_LDKSendShutdown_Body;
+   bool is_owned;
+} LDKClosingSigned;
 
-typedef struct LDKMessageSendEvent_LDKSendChannelReestablish_Body {
+
+
+/**
+ * A shutdown message to be sent or received from a peer
+ */
+typedef struct MUST_USE_STRUCT LDKShutdown {
    /**
-    * The node_id of the node which should receive this message
+    * A pointer to the opaque Rust object.
+    * Nearly everywhere, inner must be non-null, however in places where
+    * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   struct LDKPublicKey node_id;
+   LDKnativeShutdown *inner;
    /**
-    * The message which should be sent.
+    * Indicates that this is the only struct which contains the same pointer.
+    * Rust functions which take ownership of an object provided via an argument require
+    * this to be true and invalidate the object pointed to by inner.
     */
-   struct LDKChannelReestablish msg;
-} LDKMessageSendEvent_LDKSendChannelReestablish_Body;
+   bool is_owned;
+} LDKShutdown;
 
-typedef struct LDKMessageSendEvent_LDKBroadcastChannelAnnouncement_Body {
+
+
+/**
+ * A channel_reestablish message to be sent or received from a peer
+ */
+typedef struct MUST_USE_STRUCT LDKChannelReestablish {
    /**
-    * The channel_announcement which should be sent.
+    * A pointer to the opaque Rust object.
+    * Nearly everywhere, inner must be non-null, however in places where
+    * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   struct LDKChannelAnnouncement msg;
+   LDKnativeChannelReestablish *inner;
    /**
-    * The followup channel_update which should be sent.
+    * Indicates that this is the only struct which contains the same pointer.
+    * Rust functions which take ownership of an object provided via an argument require
+    * this to be true and invalidate the object pointed to by inner.
     */
-   struct LDKChannelUpdate update_msg;
-} LDKMessageSendEvent_LDKBroadcastChannelAnnouncement_Body;
+   bool is_owned;
+} LDKChannelReestablish;
 
-typedef struct LDKMessageSendEvent_LDKBroadcastNodeAnnouncement_Body {
+
+
+/**
+ * A channel_announcement message to be sent or received from a peer
+ */
+typedef struct MUST_USE_STRUCT LDKChannelAnnouncement {
    /**
-    * The node_announcement which should be sent.
+    * A pointer to the opaque Rust object.
+    * Nearly everywhere, inner must be non-null, however in places where
+    * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   struct LDKNodeAnnouncement msg;
-} LDKMessageSendEvent_LDKBroadcastNodeAnnouncement_Body;
-
-typedef struct LDKMessageSendEvent_LDKBroadcastChannelUpdate_Body {
+   LDKnativeChannelAnnouncement *inner;
    /**
-    * The channel_update which should be sent.
+    * Indicates that this is the only struct which contains the same pointer.
+    * Rust functions which take ownership of an object provided via an argument require
+    * this to be true and invalidate the object pointed to by inner.
     */
-   struct LDKChannelUpdate msg;
-} LDKMessageSendEvent_LDKBroadcastChannelUpdate_Body;
+   bool is_owned;
+} LDKChannelAnnouncement;
 
-typedef struct LDKMessageSendEvent_LDKHandleError_Body {
+
+
+/**
+ * A channel_update message to be sent or received from a peer
+ */
+typedef struct MUST_USE_STRUCT LDKChannelUpdate {
    /**
-    * The node_id of the node which should receive this message
+    * A pointer to the opaque Rust object.
+    * Nearly everywhere, inner must be non-null, however in places where
+    * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   struct LDKPublicKey node_id;
+   LDKnativeChannelUpdate *inner;
    /**
-    * The action which should be taken.
+    * Indicates that this is the only struct which contains the same pointer.
+    * Rust functions which take ownership of an object provided via an argument require
+    * this to be true and invalidate the object pointed to by inner.
     */
-   struct LDKErrorAction action;
-} LDKMessageSendEvent_LDKHandleError_Body;
+   bool is_owned;
+} LDKChannelUpdate;
 
-typedef struct LDKMessageSendEvent_LDKPaymentFailureNetworkUpdate_Body {
-   /**
-    * The channel/node update which should be sent to NetGraphMsgHandler
-    */
-   struct LDKHTLCFailChannelUpdate update;
-} LDKMessageSendEvent_LDKPaymentFailureNetworkUpdate_Body;
 
-typedef struct LDKMessageSendEvent_LDKSendChannelRangeQuery_Body {
+
+/**
+ * A node_announcement message to be sent or received from a peer
+ */
+typedef struct MUST_USE_STRUCT LDKNodeAnnouncement {
    /**
-    * The node_id of this message recipient
+    * A pointer to the opaque Rust object.
+    * Nearly everywhere, inner must be non-null, however in places where
+    * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   struct LDKPublicKey node_id;
+   LDKnativeNodeAnnouncement *inner;
    /**
-    * The query_channel_range which should be sent.
+    * Indicates that this is the only struct which contains the same pointer.
+    * Rust functions which take ownership of an object provided via an argument require
+    * this to be true and invalidate the object pointed to by inner.
     */
-   struct LDKQueryChannelRange msg;
-} LDKMessageSendEvent_LDKSendChannelRangeQuery_Body;
+   bool is_owned;
+} LDKNodeAnnouncement;
 
-typedef struct LDKMessageSendEvent_LDKSendShortIdsQuery_Body {
+
+
+/**
+ * An error message to be sent or received from a peer
+ */
+typedef struct MUST_USE_STRUCT LDKErrorMessage {
    /**
-    * The node_id of this message recipient
+    * A pointer to the opaque Rust object.
+    * Nearly everywhere, inner must be non-null, however in places where
+    * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   struct LDKPublicKey node_id;
+   LDKnativeErrorMessage *inner;
    /**
-    * The query_short_channel_ids which should be sent.
+    * Indicates that this is the only struct which contains the same pointer.
+    * Rust functions which take ownership of an object provided via an argument require
+    * this to be true and invalidate the object pointed to by inner.
     */
-   struct LDKQueryShortChannelIds msg;
-} LDKMessageSendEvent_LDKSendShortIdsQuery_Body;
+   bool is_owned;
+} LDKErrorMessage;
 
-typedef struct LDKMessageSendEvent_LDKSendReplyChannelRange_Body {
+/**
+ * Used to put an error message in a LightningError
+ */
+typedef enum LDKErrorAction_Tag {
    /**
-    * The node_id of this message recipient
+    * The peer took some action which made us think they were useless. Disconnect them.
     */
-   struct LDKPublicKey node_id;
+   LDKErrorAction_DisconnectPeer,
    /**
-    * The reply_channel_range which should be sent.
+    * The peer did something harmless that we weren't able to process, just log and ignore
     */
-   struct LDKReplyChannelRange msg;
-} LDKMessageSendEvent_LDKSendReplyChannelRange_Body;
-
-typedef struct MUST_USE_STRUCT LDKMessageSendEvent {
-   LDKMessageSendEvent_Tag tag;
-   union {
-      LDKMessageSendEvent_LDKSendAcceptChannel_Body send_accept_channel;
-      LDKMessageSendEvent_LDKSendOpenChannel_Body send_open_channel;
-      LDKMessageSendEvent_LDKSendFundingCreated_Body send_funding_created;
-      LDKMessageSendEvent_LDKSendFundingSigned_Body send_funding_signed;
-      LDKMessageSendEvent_LDKSendFundingLocked_Body send_funding_locked;
-      LDKMessageSendEvent_LDKSendAnnouncementSignatures_Body send_announcement_signatures;
-      LDKMessageSendEvent_LDKUpdateHTLCs_Body update_htl_cs;
-      LDKMessageSendEvent_LDKSendRevokeAndACK_Body send_revoke_and_ack;
-      LDKMessageSendEvent_LDKSendClosingSigned_Body send_closing_signed;
-      LDKMessageSendEvent_LDKSendShutdown_Body send_shutdown;
-      LDKMessageSendEvent_LDKSendChannelReestablish_Body send_channel_reestablish;
-      LDKMessageSendEvent_LDKBroadcastChannelAnnouncement_Body broadcast_channel_announcement;
-      LDKMessageSendEvent_LDKBroadcastNodeAnnouncement_Body broadcast_node_announcement;
-      LDKMessageSendEvent_LDKBroadcastChannelUpdate_Body broadcast_channel_update;
-      LDKMessageSendEvent_LDKHandleError_Body handle_error;
-      LDKMessageSendEvent_LDKPaymentFailureNetworkUpdate_Body payment_failure_network_update;
-      LDKMessageSendEvent_LDKSendChannelRangeQuery_Body send_channel_range_query;
-      LDKMessageSendEvent_LDKSendShortIdsQuery_Body send_short_ids_query;
-      LDKMessageSendEvent_LDKSendReplyChannelRange_Body send_reply_channel_range;
-   };
-} LDKMessageSendEvent;
-
-/**
- * A dynamically-allocated array of crate::lightning::util::events::MessageSendEvents of arbitrary size.
- * This corresponds to std::vector in C++
- */
-typedef struct LDKCVec_MessageSendEventZ {
+   LDKErrorAction_IgnoreError,
    /**
-    * The elements in the array.
-    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+    * The peer did something incorrect. Tell them.
     */
-   struct LDKMessageSendEvent *data;
+   LDKErrorAction_SendErrorMessage,
    /**
-    * The number of elements pointed to by `data`.
+    * Must be last for serialization purposes
     */
-   uintptr_t datalen;
-} LDKCVec_MessageSendEventZ;
+   LDKErrorAction_Sentinel,
+} LDKErrorAction_Tag;
 
-/**
- * The contents of CResult_boolLightningErrorZ
- */
-typedef union LDKCResult_boolLightningErrorZPtr {
-   /**
-    * A pointer to the contents in the success state.
-    * Reading from this pointer when `result_ok` is not set is undefined.
-    */
-   bool *result;
+typedef struct LDKErrorAction_LDKDisconnectPeer_Body {
    /**
-    * A pointer to the contents in the error state.
-    * Reading from this pointer when `result_ok` is set is undefined.
+    * An error message which we should make an effort to send before we disconnect.
     */
-   struct LDKLightningError *err;
-} LDKCResult_boolLightningErrorZPtr;
+   struct LDKErrorMessage msg;
+} LDKErrorAction_LDKDisconnectPeer_Body;
 
-/**
- * A CResult_boolLightningErrorZ represents the result of a fallible operation,
- * containing a bool on success and a crate::lightning::ln::msgs::LightningError on failure.
- * `result_ok` indicates the overall state, and the contents are provided via `contents`.
- */
-typedef struct LDKCResult_boolLightningErrorZ {
-   /**
-    * The contents of this CResult_boolLightningErrorZ, accessible via either
-    * `err` or `result` depending on the state of `result_ok`.
-    */
-   union LDKCResult_boolLightningErrorZPtr contents;
+typedef struct LDKErrorAction_LDKSendErrorMessage_Body {
    /**
-    * Whether this CResult_boolLightningErrorZ represents a success state.
+    * The message to send.
     */
-   bool result_ok;
-} LDKCResult_boolLightningErrorZ;
+   struct LDKErrorMessage msg;
+} LDKErrorAction_LDKSendErrorMessage_Body;
+
+typedef struct MUST_USE_STRUCT LDKErrorAction {
+   LDKErrorAction_Tag tag;
+   union {
+      LDKErrorAction_LDKDisconnectPeer_Body disconnect_peer;
+      LDKErrorAction_LDKSendErrorMessage_Body send_error_message;
+   };
+} LDKErrorAction;
 
 /**
- * A tuple of 3 elements. See the individual fields for the types contained.
+ * The information we received from a peer along the route of a payment we originated. This is
+ * returned by ChannelMessageHandler::handle_update_fail_htlc to be passed into
+ * RoutingMessageHandler::handle_htlc_fail_channel_update to update our network map.
  */
-typedef struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ {
+typedef enum LDKHTLCFailChannelUpdate_Tag {
    /**
-    * The element at position 0
+    * We received an error which included a full ChannelUpdate message.
     */
-   struct LDKChannelAnnouncement a;
+   LDKHTLCFailChannelUpdate_ChannelUpdateMessage,
    /**
-    * The element at position 1
+    * We received an error which indicated only that a channel has been closed
     */
-   struct LDKChannelUpdate b;
+   LDKHTLCFailChannelUpdate_ChannelClosed,
    /**
-    * The element at position 2
+    * We received an error which indicated only that a node has failed
     */
-   struct LDKChannelUpdate c;
-} LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ;
-
-/**
- * A dynamically-allocated array of crate::c_types::derived::C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZs of arbitrary size.
- * This corresponds to std::vector in C++
- */
-typedef struct LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
+   LDKHTLCFailChannelUpdate_NodeFailure,
    /**
-    * The elements in the array.
-    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+    * Must be last for serialization purposes
     */
-   struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *data;
+   LDKHTLCFailChannelUpdate_Sentinel,
+} LDKHTLCFailChannelUpdate_Tag;
+
+typedef struct LDKHTLCFailChannelUpdate_LDKChannelUpdateMessage_Body {
    /**
-    * The number of elements pointed to by `data`.
+    * The unwrapped message we received
     */
-   uintptr_t datalen;
-} LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ;
+   struct LDKChannelUpdate msg;
+} LDKHTLCFailChannelUpdate_LDKChannelUpdateMessage_Body;
 
-/**
- * A dynamically-allocated array of crate::lightning::ln::msgs::NodeAnnouncements of arbitrary size.
- * This corresponds to std::vector in C++
- */
-typedef struct LDKCVec_NodeAnnouncementZ {
+typedef struct LDKHTLCFailChannelUpdate_LDKChannelClosed_Body {
    /**
-    * The elements in the array.
-    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+    * The short_channel_id which has now closed.
     */
-   struct LDKNodeAnnouncement *data;
+   uint64_t short_channel_id;
    /**
-    * The number of elements pointed to by `data`.
+    * when this true, this channel should be permanently removed from the
+    * consideration. Otherwise, this channel can be restored as new channel_update is received
     */
-   uintptr_t datalen;
-} LDKCVec_NodeAnnouncementZ;
+   bool is_permanent;
+} LDKHTLCFailChannelUpdate_LDKChannelClosed_Body;
 
-/**
- * The contents of CResult_NoneLightningErrorZ
- */
-typedef union LDKCResult_NoneLightningErrorZPtr {
+typedef struct LDKHTLCFailChannelUpdate_LDKNodeFailure_Body {
    /**
-    * Note that this value is always NULL, as there are no contents in the OK variant
+    * The node_id that has failed.
     */
-   void *result;
+   struct LDKPublicKey node_id;
    /**
-    * A pointer to the contents in the error state.
-    * Reading from this pointer when `result_ok` is set is undefined.
+    * when this true, node should be permanently removed from the
+    * consideration. Otherwise, the channels connected to this node can be
+    * restored as new channel_update is received
     */
-   struct LDKLightningError *err;
-} LDKCResult_NoneLightningErrorZPtr;
+   bool is_permanent;
+} LDKHTLCFailChannelUpdate_LDKNodeFailure_Body;
+
+typedef struct MUST_USE_STRUCT LDKHTLCFailChannelUpdate {
+   LDKHTLCFailChannelUpdate_Tag tag;
+   union {
+      LDKHTLCFailChannelUpdate_LDKChannelUpdateMessage_Body channel_update_message;
+      LDKHTLCFailChannelUpdate_LDKChannelClosed_Body channel_closed;
+      LDKHTLCFailChannelUpdate_LDKNodeFailure_Body node_failure;
+   };
+} LDKHTLCFailChannelUpdate;
+
+
 
 /**
- * A CResult_NoneLightningErrorZ represents the result of a fallible operation,
- * containing a () on success and a crate::lightning::ln::msgs::LightningError on failure.
- * `result_ok` indicates the overall state, and the contents are provided via `contents`.
+ * A query_channel_range message is used to query a peer for channel
+ * UTXOs in a range of blocks. The recipient of a query makes a best
+ * effort to reply to the query using one or more reply_channel_range
+ * messages.
  */
-typedef struct LDKCResult_NoneLightningErrorZ {
+typedef struct MUST_USE_STRUCT LDKQueryChannelRange {
    /**
-    * The contents of this CResult_NoneLightningErrorZ, accessible via either
-    * `err` or `result` depending on the state of `result_ok`.
+    * A pointer to the opaque Rust object.
+    * Nearly everywhere, inner must be non-null, however in places where
+    * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   union LDKCResult_NoneLightningErrorZPtr contents;
+   LDKnativeQueryChannelRange *inner;
    /**
-    * Whether this CResult_NoneLightningErrorZ represents a success state.
+    * Indicates that this is the only struct which contains the same pointer.
+    * Rust functions which take ownership of an object provided via an argument require
+    * this to be true and invalidate the object pointed to by inner.
     */
-   bool result_ok;
-} LDKCResult_NoneLightningErrorZ;
+   bool is_owned;
+} LDKQueryChannelRange;
+
+
 
 /**
- * A dynamically-allocated array of crate::c_types::PublicKeys of arbitrary size.
- * This corresponds to std::vector in C++
+ * A query_short_channel_ids message is used to query a peer for
+ * routing gossip messages related to one or more short_channel_ids.
+ * The query recipient will reply with the latest, if available,
+ * channel_announcement, channel_update and node_announcement messages
+ * it maintains for the requested short_channel_ids followed by a
+ * reply_short_channel_ids_end message. The short_channel_ids sent in
+ * this query are encoded. We only support encoding_type=0 uncompressed
+ * serialization and do not support encoding_type=1 zlib serialization.
  */
-typedef struct LDKCVec_PublicKeyZ {
+typedef struct MUST_USE_STRUCT LDKQueryShortChannelIds {
    /**
-    * The elements in the array.
-    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+    * A pointer to the opaque Rust object.
+    * Nearly everywhere, inner must be non-null, however in places where
+    * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   struct LDKPublicKey *data;
+   LDKnativeQueryShortChannelIds *inner;
    /**
-    * The number of elements pointed to by `data`.
+    * Indicates that this is the only struct which contains the same pointer.
+    * Rust functions which take ownership of an object provided via an argument require
+    * this to be true and invalidate the object pointed to by inner.
     */
-   uintptr_t datalen;
-} LDKCVec_PublicKeyZ;
+   bool is_owned;
+} LDKQueryShortChannelIds;
 
 
 
 /**
- * Error for PeerManager errors. If you get one of these, you must disconnect the socket and
- * generate no further read_event/write_buffer_space_avail/socket_disconnected calls for the
- * descriptor.
+ * A reply_channel_range message is a reply to a query_channel_range
+ * message. Multiple reply_channel_range messages can be sent in reply
+ * to a single query_channel_range message. The query recipient makes a
+ * best effort to respond based on their local network view which may
+ * not be a perfect view of the network. The short_channel_ids in the
+ * reply are encoded. We only support encoding_type=0 uncompressed
+ * serialization and do not support encoding_type=1 zlib serialization.
  */
-typedef struct MUST_USE_STRUCT LDKPeerHandleError {
+typedef struct MUST_USE_STRUCT LDKReplyChannelRange {
    /**
     * A pointer to the opaque Rust object.
     * Nearly everywhere, inner must be non-null, however in places where
     * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   LDKnativePeerHandleError *inner;
+   LDKnativeReplyChannelRange *inner;
    /**
     * Indicates that this is the only struct which contains the same pointer.
     * Rust functions which take ownership of an object provided via an argument require
     * this to be true and invalidate the object pointed to by inner.
     */
    bool is_owned;
-} LDKPeerHandleError;
+} LDKReplyChannelRange;
 
 /**
- * The contents of CResult_CVec_u8ZPeerHandleErrorZ
+ * An event generated by ChannelManager which indicates a message should be sent to a peer (or
+ * broadcast to most peers).
+ * These events are handled by PeerManager::process_events if you are using a PeerManager.
  */
-typedef union LDKCResult_CVec_u8ZPeerHandleErrorZPtr {
+typedef enum LDKMessageSendEvent_Tag {
    /**
-    * A pointer to the contents in the success state.
-    * Reading from this pointer when `result_ok` is not set is undefined.
+    * Used to indicate that we've accepted a channel open and should send the accept_channel
+    * message provided to the given peer.
     */
-   struct LDKCVec_u8Z *result;
+   LDKMessageSendEvent_SendAcceptChannel,
    /**
-    * A pointer to the contents in the error state.
-    * Reading from this pointer when `result_ok` is set is undefined.
-    */
-   struct LDKPeerHandleError *err;
-} LDKCResult_CVec_u8ZPeerHandleErrorZPtr;
-
-/**
- * A CResult_CVec_u8ZPeerHandleErrorZ represents the result of a fallible operation,
- * containing a crate::c_types::derived::CVec_u8Z on success and a crate::lightning::ln::peer_handler::PeerHandleError on failure.
- * `result_ok` indicates the overall state, and the contents are provided via `contents`.
- */
-typedef struct LDKCResult_CVec_u8ZPeerHandleErrorZ {
+    * Used to indicate that we've initiated a channel open and should send the open_channel
+    * message provided to the given peer.
+    */
+   LDKMessageSendEvent_SendOpenChannel,
    /**
-    * The contents of this CResult_CVec_u8ZPeerHandleErrorZ, accessible via either
-    * `err` or `result` depending on the state of `result_ok`.
+    * Used to indicate that a funding_created message should be sent to the peer with the given node_id.
     */
-   union LDKCResult_CVec_u8ZPeerHandleErrorZPtr contents;
+   LDKMessageSendEvent_SendFundingCreated,
    /**
-    * Whether this CResult_CVec_u8ZPeerHandleErrorZ represents a success state.
+    * Used to indicate that a funding_signed message should be sent to the peer with the given node_id.
     */
-   bool result_ok;
-} LDKCResult_CVec_u8ZPeerHandleErrorZ;
-
-/**
- * The contents of CResult_NonePeerHandleErrorZ
- */
-typedef union LDKCResult_NonePeerHandleErrorZPtr {
+   LDKMessageSendEvent_SendFundingSigned,
    /**
-    * Note that this value is always NULL, as there are no contents in the OK variant
+    * Used to indicate that a funding_locked message should be sent to the peer with the given node_id.
     */
-   void *result;
+   LDKMessageSendEvent_SendFundingLocked,
    /**
-    * A pointer to the contents in the error state.
-    * Reading from this pointer when `result_ok` is set is undefined.
+    * Used to indicate that an announcement_signatures message should be sent to the peer with the given node_id.
     */
-   struct LDKPeerHandleError *err;
-} LDKCResult_NonePeerHandleErrorZPtr;
-
-/**
- * A CResult_NonePeerHandleErrorZ represents the result of a fallible operation,
- * containing a () on success and a crate::lightning::ln::peer_handler::PeerHandleError on failure.
- * `result_ok` indicates the overall state, and the contents are provided via `contents`.
- */
-typedef struct LDKCResult_NonePeerHandleErrorZ {
+   LDKMessageSendEvent_SendAnnouncementSignatures,
    /**
-    * The contents of this CResult_NonePeerHandleErrorZ, accessible via either
-    * `err` or `result` depending on the state of `result_ok`.
+    * Used to indicate that a series of HTLC update messages, as well as a commitment_signed
+    * message should be sent to the peer with the given node_id.
     */
-   union LDKCResult_NonePeerHandleErrorZPtr contents;
+   LDKMessageSendEvent_UpdateHTLCs,
    /**
-    * Whether this CResult_NonePeerHandleErrorZ represents a success state.
+    * Used to indicate that a revoke_and_ack message should be sent to the peer with the given node_id.
     */
-   bool result_ok;
-} LDKCResult_NonePeerHandleErrorZ;
-
-/**
- * The contents of CResult_boolPeerHandleErrorZ
- */
-typedef union LDKCResult_boolPeerHandleErrorZPtr {
+   LDKMessageSendEvent_SendRevokeAndACK,
    /**
-    * A pointer to the contents in the success state.
-    * Reading from this pointer when `result_ok` is not set is undefined.
+    * Used to indicate that a closing_signed message should be sent to the peer with the given node_id.
     */
-   bool *result;
+   LDKMessageSendEvent_SendClosingSigned,
    /**
-    * A pointer to the contents in the error state.
-    * Reading from this pointer when `result_ok` is set is undefined.
+    * Used to indicate that a shutdown message should be sent to the peer with the given node_id.
     */
-   struct LDKPeerHandleError *err;
-} LDKCResult_boolPeerHandleErrorZPtr;
-
-/**
- * A CResult_boolPeerHandleErrorZ represents the result of a fallible operation,
- * containing a bool on success and a crate::lightning::ln::peer_handler::PeerHandleError on failure.
- * `result_ok` indicates the overall state, and the contents are provided via `contents`.
- */
-typedef struct LDKCResult_boolPeerHandleErrorZ {
+   LDKMessageSendEvent_SendShutdown,
    /**
-    * The contents of this CResult_boolPeerHandleErrorZ, accessible via either
-    * `err` or `result` depending on the state of `result_ok`.
+    * Used to indicate that a channel_reestablish message should be sent to the peer with the given node_id.
     */
-   union LDKCResult_boolPeerHandleErrorZPtr contents;
+   LDKMessageSendEvent_SendChannelReestablish,
    /**
-    * Whether this CResult_boolPeerHandleErrorZ represents a success state.
+    * Used to indicate that a channel_announcement and channel_update should be broadcast to all
+    * peers (except the peer with node_id either msg.contents.node_id_1 or msg.contents.node_id_2).
+    *
+    * Note that after doing so, you very likely (unless you did so very recently) want to call
+    * ChannelManager::broadcast_node_announcement to trigger a BroadcastNodeAnnouncement event.
+    * This ensures that any nodes which see our channel_announcement also have a relevant
+    * node_announcement, including relevant feature flags which may be important for routing
+    * through or to us.
     */
-   bool result_ok;
-} LDKCResult_boolPeerHandleErrorZ;
-
-/**
- * The contents of CResult_TxOutAccessErrorZ
- */
-typedef union LDKCResult_TxOutAccessErrorZPtr {
+   LDKMessageSendEvent_BroadcastChannelAnnouncement,
    /**
-    * A pointer to the contents in the success state.
-    * Reading from this pointer when `result_ok` is not set is undefined.
+    * Used to indicate that a node_announcement should be broadcast to all peers.
     */
-   struct LDKTxOut *result;
+   LDKMessageSendEvent_BroadcastNodeAnnouncement,
    /**
-    * A pointer to the contents in the error state.
-    * Reading from this pointer when `result_ok` is set is undefined.
+    * Used to indicate that a channel_update should be broadcast to all peers.
     */
-   enum LDKAccessError *err;
-} LDKCResult_TxOutAccessErrorZPtr;
-
-/**
- * A CResult_TxOutAccessErrorZ represents the result of a fallible operation,
- * containing a crate::c_types::TxOut on success and a crate::lightning::chain::AccessError on failure.
- * `result_ok` indicates the overall state, and the contents are provided via `contents`.
- */
-typedef struct LDKCResult_TxOutAccessErrorZ {
+   LDKMessageSendEvent_BroadcastChannelUpdate,
    /**
-    * The contents of this CResult_TxOutAccessErrorZ, accessible via either
-    * `err` or `result` depending on the state of `result_ok`.
+    * Broadcast an error downstream to be handled
     */
-   union LDKCResult_TxOutAccessErrorZPtr contents;
+   LDKMessageSendEvent_HandleError,
    /**
-    * Whether this CResult_TxOutAccessErrorZ represents a success state.
+    * When a payment fails we may receive updates back from the hop where it failed. In such
+    * cases this event is generated so that we can inform the network graph of this information.
     */
-   bool result_ok;
-} LDKCResult_TxOutAccessErrorZ;
-
-/**
- * An enum which can either contain a crate::c_types::derived::C2Tuple_usizeTransactionZ or not
- */
-typedef enum LDKCOption_C2Tuple_usizeTransactionZZ_Tag {
+   LDKMessageSendEvent_PaymentFailureNetworkUpdate,
    /**
-    * When we're in this state, this COption_C2Tuple_usizeTransactionZZ contains a crate::c_types::derived::C2Tuple_usizeTransactionZ
+    * Query a peer for channels with funding transaction UTXOs in a block range.
     */
-   LDKCOption_C2Tuple_usizeTransactionZZ_Some,
+   LDKMessageSendEvent_SendChannelRangeQuery,
    /**
-    * When we're in this state, this COption_C2Tuple_usizeTransactionZZ contains nothing
+    * Request routing gossip messages from a peer for a list of channels identified by
+    * their short_channel_ids.
     */
-   LDKCOption_C2Tuple_usizeTransactionZZ_None,
+   LDKMessageSendEvent_SendShortIdsQuery,
+   /**
+    * Sends a reply to a channel range query. This may be one of several SendReplyChannelRange events
+    * emitted during processing of the query.
+    */
+   LDKMessageSendEvent_SendReplyChannelRange,
    /**
     * Must be last for serialization purposes
     */
-   LDKCOption_C2Tuple_usizeTransactionZZ_Sentinel,
-} LDKCOption_C2Tuple_usizeTransactionZZ_Tag;
-
-typedef struct LDKCOption_C2Tuple_usizeTransactionZZ {
-   LDKCOption_C2Tuple_usizeTransactionZZ_Tag tag;
-   union {
-      struct {
-         struct LDKC2Tuple_usizeTransactionZ some;
-      };
-   };
-} LDKCOption_C2Tuple_usizeTransactionZZ;
-
-
+   LDKMessageSendEvent_Sentinel,
+} LDKMessageSendEvent_Tag;
 
-/**
- * Details about one direction of a channel. Received
- * within a channel update.
- */
-typedef struct MUST_USE_STRUCT LDKDirectionalChannelInfo {
+typedef struct LDKMessageSendEvent_LDKSendAcceptChannel_Body {
    /**
-    * A pointer to the opaque Rust object.
-    * Nearly everywhere, inner must be non-null, however in places where
-    * the Rust equivalent takes an Option, it may be set to null to indicate None.
+    * The node_id of the node which should receive this message
     */
-   LDKnativeDirectionalChannelInfo *inner;
+   struct LDKPublicKey node_id;
    /**
-    * Indicates that this is the only struct which contains the same pointer.
-    * Rust functions which take ownership of an object provided via an argument require
-    * this to be true and invalidate the object pointed to by inner.
+    * The message which should be sent.
     */
-   bool is_owned;
-} LDKDirectionalChannelInfo;
+   struct LDKAcceptChannel msg;
+} LDKMessageSendEvent_LDKSendAcceptChannel_Body;
 
-/**
- * The contents of CResult_DirectionalChannelInfoDecodeErrorZ
- */
-typedef union LDKCResult_DirectionalChannelInfoDecodeErrorZPtr {
+typedef struct LDKMessageSendEvent_LDKSendOpenChannel_Body {
    /**
-    * A pointer to the contents in the success state.
-    * Reading from this pointer when `result_ok` is not set is undefined.
+    * The node_id of the node which should receive this message
     */
-   struct LDKDirectionalChannelInfo *result;
+   struct LDKPublicKey node_id;
    /**
-    * A pointer to the contents in the error state.
-    * Reading from this pointer when `result_ok` is set is undefined.
+    * The message which should be sent.
     */
-   struct LDKDecodeError *err;
-} LDKCResult_DirectionalChannelInfoDecodeErrorZPtr;
+   struct LDKOpenChannel msg;
+} LDKMessageSendEvent_LDKSendOpenChannel_Body;
 
-/**
- * A CResult_DirectionalChannelInfoDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::routing::network_graph::DirectionalChannelInfo on success and a crate::lightning::ln::msgs::DecodeError on failure.
- * `result_ok` indicates the overall state, and the contents are provided via `contents`.
- */
-typedef struct LDKCResult_DirectionalChannelInfoDecodeErrorZ {
+typedef struct LDKMessageSendEvent_LDKSendFundingCreated_Body {
    /**
-    * The contents of this CResult_DirectionalChannelInfoDecodeErrorZ, accessible via either
-    * `err` or `result` depending on the state of `result_ok`.
+    * The node_id of the node which should receive this message
     */
-   union LDKCResult_DirectionalChannelInfoDecodeErrorZPtr contents;
+   struct LDKPublicKey node_id;
    /**
-    * Whether this CResult_DirectionalChannelInfoDecodeErrorZ represents a success state.
+    * The message which should be sent.
     */
-   bool result_ok;
-} LDKCResult_DirectionalChannelInfoDecodeErrorZ;
-
-
+   struct LDKFundingCreated msg;
+} LDKMessageSendEvent_LDKSendFundingCreated_Body;
 
-/**
- * Details about a channel (both directions).
- * Received within a channel announcement.
- */
-typedef struct MUST_USE_STRUCT LDKChannelInfo {
+typedef struct LDKMessageSendEvent_LDKSendFundingSigned_Body {
    /**
-    * A pointer to the opaque Rust object.
-    * Nearly everywhere, inner must be non-null, however in places where
-    * the Rust equivalent takes an Option, it may be set to null to indicate None.
+    * The node_id of the node which should receive this message
     */
-   LDKnativeChannelInfo *inner;
+   struct LDKPublicKey node_id;
    /**
-    * Indicates that this is the only struct which contains the same pointer.
-    * Rust functions which take ownership of an object provided via an argument require
-    * this to be true and invalidate the object pointed to by inner.
+    * The message which should be sent.
     */
-   bool is_owned;
-} LDKChannelInfo;
+   struct LDKFundingSigned msg;
+} LDKMessageSendEvent_LDKSendFundingSigned_Body;
 
-/**
- * The contents of CResult_ChannelInfoDecodeErrorZ
- */
-typedef union LDKCResult_ChannelInfoDecodeErrorZPtr {
+typedef struct LDKMessageSendEvent_LDKSendFundingLocked_Body {
    /**
-    * A pointer to the contents in the success state.
-    * Reading from this pointer when `result_ok` is not set is undefined.
+    * The node_id of the node which should receive these message(s)
     */
-   struct LDKChannelInfo *result;
+   struct LDKPublicKey node_id;
    /**
-    * A pointer to the contents in the error state.
-    * Reading from this pointer when `result_ok` is set is undefined.
+    * The funding_locked message which should be sent.
     */
-   struct LDKDecodeError *err;
-} LDKCResult_ChannelInfoDecodeErrorZPtr;
+   struct LDKFundingLocked msg;
+} LDKMessageSendEvent_LDKSendFundingLocked_Body;
 
-/**
- * A CResult_ChannelInfoDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::routing::network_graph::ChannelInfo on success and a crate::lightning::ln::msgs::DecodeError on failure.
- * `result_ok` indicates the overall state, and the contents are provided via `contents`.
- */
-typedef struct LDKCResult_ChannelInfoDecodeErrorZ {
+typedef struct LDKMessageSendEvent_LDKSendAnnouncementSignatures_Body {
    /**
-    * The contents of this CResult_ChannelInfoDecodeErrorZ, accessible via either
-    * `err` or `result` depending on the state of `result_ok`.
+    * The node_id of the node which should receive these message(s)
     */
-   union LDKCResult_ChannelInfoDecodeErrorZPtr contents;
+   struct LDKPublicKey node_id;
    /**
-    * Whether this CResult_ChannelInfoDecodeErrorZ represents a success state.
+    * The announcement_signatures message which should be sent.
     */
-   bool result_ok;
-} LDKCResult_ChannelInfoDecodeErrorZ;
-
-
+   struct LDKAnnouncementSignatures msg;
+} LDKMessageSendEvent_LDKSendAnnouncementSignatures_Body;
 
-/**
- * Fees for routing via a given channel or a node
- */
-typedef struct MUST_USE_STRUCT LDKRoutingFees {
+typedef struct LDKMessageSendEvent_LDKUpdateHTLCs_Body {
    /**
-    * A pointer to the opaque Rust object.
-    * Nearly everywhere, inner must be non-null, however in places where
-    * the Rust equivalent takes an Option, it may be set to null to indicate None.
+    * The node_id of the node which should receive these message(s)
     */
-   LDKnativeRoutingFees *inner;
+   struct LDKPublicKey node_id;
    /**
-    * Indicates that this is the only struct which contains the same pointer.
-    * Rust functions which take ownership of an object provided via an argument require
-    * this to be true and invalidate the object pointed to by inner.
+    * The update messages which should be sent. ALL messages in the struct should be sent!
     */
-   bool is_owned;
-} LDKRoutingFees;
+   struct LDKCommitmentUpdate updates;
+} LDKMessageSendEvent_LDKUpdateHTLCs_Body;
 
-/**
- * The contents of CResult_RoutingFeesDecodeErrorZ
- */
-typedef union LDKCResult_RoutingFeesDecodeErrorZPtr {
+typedef struct LDKMessageSendEvent_LDKSendRevokeAndACK_Body {
    /**
-    * A pointer to the contents in the success state.
-    * Reading from this pointer when `result_ok` is not set is undefined.
+    * The node_id of the node which should receive this message
     */
-   struct LDKRoutingFees *result;
+   struct LDKPublicKey node_id;
    /**
-    * A pointer to the contents in the error state.
-    * Reading from this pointer when `result_ok` is set is undefined.
+    * The message which should be sent.
     */
-   struct LDKDecodeError *err;
-} LDKCResult_RoutingFeesDecodeErrorZPtr;
+   struct LDKRevokeAndACK msg;
+} LDKMessageSendEvent_LDKSendRevokeAndACK_Body;
 
-/**
- * A CResult_RoutingFeesDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::routing::network_graph::RoutingFees on success and a crate::lightning::ln::msgs::DecodeError on failure.
- * `result_ok` indicates the overall state, and the contents are provided via `contents`.
- */
-typedef struct LDKCResult_RoutingFeesDecodeErrorZ {
+typedef struct LDKMessageSendEvent_LDKSendClosingSigned_Body {
    /**
-    * The contents of this CResult_RoutingFeesDecodeErrorZ, accessible via either
-    * `err` or `result` depending on the state of `result_ok`.
+    * The node_id of the node which should receive this message
     */
-   union LDKCResult_RoutingFeesDecodeErrorZPtr contents;
+   struct LDKPublicKey node_id;
    /**
-    * Whether this CResult_RoutingFeesDecodeErrorZ represents a success state.
+    * The message which should be sent.
     */
-   bool result_ok;
-} LDKCResult_RoutingFeesDecodeErrorZ;
+   struct LDKClosingSigned msg;
+} LDKMessageSendEvent_LDKSendClosingSigned_Body;
 
-/**
- * A 4-byte byte array.
- */
-typedef struct LDKFourBytes {
+typedef struct LDKMessageSendEvent_LDKSendShutdown_Body {
    /**
-    * The four bytes
+    * The node_id of the node which should receive this message
     */
-   uint8_t data[4];
-} LDKFourBytes;
-
-/**
- * A 16-byte byte array.
- */
-typedef struct LDKSixteenBytes {
+   struct LDKPublicKey node_id;
    /**
-    * The sixteen bytes
+    * The message which should be sent.
     */
-   uint8_t data[16];
-} LDKSixteenBytes;
+   struct LDKShutdown msg;
+} LDKMessageSendEvent_LDKSendShutdown_Body;
 
-/**
- * A 10-byte byte array.
- */
-typedef struct LDKTenBytes {
+typedef struct LDKMessageSendEvent_LDKSendChannelReestablish_Body {
    /**
-    * The ten bytes
+    * The node_id of the node which should receive this message
     */
-   uint8_t data[10];
-} LDKTenBytes;
-
-/**
- * An address which can be used to connect to a remote peer
- */
-typedef enum LDKNetAddress_Tag {
+   struct LDKPublicKey node_id;
    /**
-    * An IPv4 address/port on which the peer is listening.
+    * The message which should be sent.
     */
-   LDKNetAddress_IPv4,
+   struct LDKChannelReestablish msg;
+} LDKMessageSendEvent_LDKSendChannelReestablish_Body;
+
+typedef struct LDKMessageSendEvent_LDKBroadcastChannelAnnouncement_Body {
    /**
-    * An IPv6 address/port on which the peer is listening.
+    * The channel_announcement which should be sent.
     */
-   LDKNetAddress_IPv6,
+   struct LDKChannelAnnouncement msg;
    /**
-    * An old-style Tor onion address/port on which the peer is listening.
+    * The followup channel_update which should be sent.
     */
-   LDKNetAddress_OnionV2,
+   struct LDKChannelUpdate update_msg;
+} LDKMessageSendEvent_LDKBroadcastChannelAnnouncement_Body;
+
+typedef struct LDKMessageSendEvent_LDKBroadcastNodeAnnouncement_Body {
    /**
-    * A new-style Tor onion address/port on which the peer is listening.
-    * To create the human-readable \"hostname\", concatenate ed25519_pubkey, checksum, and version,
-    * wrap as base32 and append \".onion\".
+    * The node_announcement which should be sent.
     */
-   LDKNetAddress_OnionV3,
+   struct LDKNodeAnnouncement msg;
+} LDKMessageSendEvent_LDKBroadcastNodeAnnouncement_Body;
+
+typedef struct LDKMessageSendEvent_LDKBroadcastChannelUpdate_Body {
    /**
-    * Must be last for serialization purposes
+    * The channel_update which should be sent.
     */
-   LDKNetAddress_Sentinel,
-} LDKNetAddress_Tag;
+   struct LDKChannelUpdate msg;
+} LDKMessageSendEvent_LDKBroadcastChannelUpdate_Body;
 
-typedef struct LDKNetAddress_LDKIPv4_Body {
+typedef struct LDKMessageSendEvent_LDKHandleError_Body {
    /**
-    * The 4-byte IPv4 address
+    * The node_id of the node which should receive this message
     */
-   struct LDKFourBytes addr;
+   struct LDKPublicKey node_id;
    /**
-    * The port on which the node is listening
+    * The action which should be taken.
     */
-   uint16_t port;
-} LDKNetAddress_LDKIPv4_Body;
+   struct LDKErrorAction action;
+} LDKMessageSendEvent_LDKHandleError_Body;
 
-typedef struct LDKNetAddress_LDKIPv6_Body {
-   /**
-    * The 16-byte IPv6 address
-    */
-   struct LDKSixteenBytes addr;
+typedef struct LDKMessageSendEvent_LDKPaymentFailureNetworkUpdate_Body {
    /**
-    * The port on which the node is listening
+    * The channel/node update which should be sent to NetGraphMsgHandler
     */
-   uint16_t port;
-} LDKNetAddress_LDKIPv6_Body;
+   struct LDKHTLCFailChannelUpdate update;
+} LDKMessageSendEvent_LDKPaymentFailureNetworkUpdate_Body;
 
-typedef struct LDKNetAddress_LDKOnionV2_Body {
+typedef struct LDKMessageSendEvent_LDKSendChannelRangeQuery_Body {
    /**
-    * The bytes (usually encoded in base32 with \".onion\" appended)
+    * The node_id of this message recipient
     */
-   struct LDKTenBytes addr;
+   struct LDKPublicKey node_id;
    /**
-    * The port on which the node is listening
+    * The query_channel_range which should be sent.
     */
-   uint16_t port;
-} LDKNetAddress_LDKOnionV2_Body;
+   struct LDKQueryChannelRange msg;
+} LDKMessageSendEvent_LDKSendChannelRangeQuery_Body;
 
-typedef struct LDKNetAddress_LDKOnionV3_Body {
+typedef struct LDKMessageSendEvent_LDKSendShortIdsQuery_Body {
    /**
-    * The ed25519 long-term public key of the peer
+    * The node_id of this message recipient
     */
-   struct LDKThirtyTwoBytes ed25519_pubkey;
+   struct LDKPublicKey node_id;
    /**
-    * The checksum of the pubkey and version, as included in the onion address
+    * The query_short_channel_ids which should be sent.
     */
-   uint16_t checksum;
+   struct LDKQueryShortChannelIds msg;
+} LDKMessageSendEvent_LDKSendShortIdsQuery_Body;
+
+typedef struct LDKMessageSendEvent_LDKSendReplyChannelRange_Body {
    /**
-    * The version byte, as defined by the Tor Onion v3 spec.
+    * The node_id of this message recipient
     */
-   uint8_t version;
+   struct LDKPublicKey node_id;
    /**
-    * The port on which the node is listening
+    * The reply_channel_range which should be sent.
     */
-   uint16_t port;
-} LDKNetAddress_LDKOnionV3_Body;
+   struct LDKReplyChannelRange msg;
+} LDKMessageSendEvent_LDKSendReplyChannelRange_Body;
 
-typedef struct MUST_USE_STRUCT LDKNetAddress {
-   LDKNetAddress_Tag tag;
+typedef struct MUST_USE_STRUCT LDKMessageSendEvent {
+   LDKMessageSendEvent_Tag tag;
    union {
-      LDKNetAddress_LDKIPv4_Body i_pv4;
-      LDKNetAddress_LDKIPv6_Body i_pv6;
-      LDKNetAddress_LDKOnionV2_Body onion_v2;
-      LDKNetAddress_LDKOnionV3_Body onion_v3;
+      LDKMessageSendEvent_LDKSendAcceptChannel_Body send_accept_channel;
+      LDKMessageSendEvent_LDKSendOpenChannel_Body send_open_channel;
+      LDKMessageSendEvent_LDKSendFundingCreated_Body send_funding_created;
+      LDKMessageSendEvent_LDKSendFundingSigned_Body send_funding_signed;
+      LDKMessageSendEvent_LDKSendFundingLocked_Body send_funding_locked;
+      LDKMessageSendEvent_LDKSendAnnouncementSignatures_Body send_announcement_signatures;
+      LDKMessageSendEvent_LDKUpdateHTLCs_Body update_htl_cs;
+      LDKMessageSendEvent_LDKSendRevokeAndACK_Body send_revoke_and_ack;
+      LDKMessageSendEvent_LDKSendClosingSigned_Body send_closing_signed;
+      LDKMessageSendEvent_LDKSendShutdown_Body send_shutdown;
+      LDKMessageSendEvent_LDKSendChannelReestablish_Body send_channel_reestablish;
+      LDKMessageSendEvent_LDKBroadcastChannelAnnouncement_Body broadcast_channel_announcement;
+      LDKMessageSendEvent_LDKBroadcastNodeAnnouncement_Body broadcast_node_announcement;
+      LDKMessageSendEvent_LDKBroadcastChannelUpdate_Body broadcast_channel_update;
+      LDKMessageSendEvent_LDKHandleError_Body handle_error;
+      LDKMessageSendEvent_LDKPaymentFailureNetworkUpdate_Body payment_failure_network_update;
+      LDKMessageSendEvent_LDKSendChannelRangeQuery_Body send_channel_range_query;
+      LDKMessageSendEvent_LDKSendShortIdsQuery_Body send_short_ids_query;
+      LDKMessageSendEvent_LDKSendReplyChannelRange_Body send_reply_channel_range;
    };
-} LDKNetAddress;
+} LDKMessageSendEvent;
 
 /**
- * A dynamically-allocated array of crate::lightning::ln::msgs::NetAddresss of arbitrary size.
+ * A dynamically-allocated array of crate::lightning::util::events::MessageSendEvents of arbitrary size.
  * This corresponds to std::vector in C++
  */
-typedef struct LDKCVec_NetAddressZ {
+typedef struct LDKCVec_MessageSendEventZ {
    /**
     * The elements in the array.
     * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
     */
-   struct LDKNetAddress *data;
+   struct LDKMessageSendEvent *data;
    /**
     * The number of elements pointed to by `data`.
     */
    uintptr_t datalen;
-} LDKCVec_NetAddressZ;
-
-
+} LDKCVec_MessageSendEventZ;
 
 /**
- * Information received in the latest node_announcement from this node.
+ * The contents of CResult_boolLightningErrorZ
  */
-typedef struct MUST_USE_STRUCT LDKNodeAnnouncementInfo {
+typedef union LDKCResult_boolLightningErrorZPtr {
    /**
-    * A pointer to the opaque Rust object.
-    * Nearly everywhere, inner must be non-null, however in places where
-    * the Rust equivalent takes an Option, it may be set to null to indicate None.
+    * A pointer to the contents in the success state.
+    * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   LDKnativeNodeAnnouncementInfo *inner;
+   bool *result;
    /**
-    * Indicates that this is the only struct which contains the same pointer.
-    * Rust functions which take ownership of an object provided via an argument require
-    * this to be true and invalidate the object pointed to by inner.
+    * A pointer to the contents in the error state.
+    * Reading from this pointer when `result_ok` is set is undefined.
     */
-   bool is_owned;
-} LDKNodeAnnouncementInfo;
+   struct LDKLightningError *err;
+} LDKCResult_boolLightningErrorZPtr;
 
 /**
- * The contents of CResult_NodeAnnouncementInfoDecodeErrorZ
+ * A CResult_boolLightningErrorZ represents the result of a fallible operation,
+ * containing a bool on success and a crate::lightning::ln::msgs::LightningError on failure.
+ * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef union LDKCResult_NodeAnnouncementInfoDecodeErrorZPtr {
+typedef struct LDKCResult_boolLightningErrorZ {
    /**
-    * A pointer to the contents in the success state.
-    * Reading from this pointer when `result_ok` is not set is undefined.
+    * The contents of this CResult_boolLightningErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   struct LDKNodeAnnouncementInfo *result;
+   union LDKCResult_boolLightningErrorZPtr contents;
    /**
-    * A pointer to the contents in the error state.
-    * Reading from this pointer when `result_ok` is set is undefined.
+    * Whether this CResult_boolLightningErrorZ represents a success state.
     */
-   struct LDKDecodeError *err;
-} LDKCResult_NodeAnnouncementInfoDecodeErrorZPtr;
+   bool result_ok;
+} LDKCResult_boolLightningErrorZ;
 
 /**
- * A CResult_NodeAnnouncementInfoDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::routing::network_graph::NodeAnnouncementInfo on success and a crate::lightning::ln::msgs::DecodeError on failure.
- * `result_ok` indicates the overall state, and the contents are provided via `contents`.
+ * A tuple of 3 elements. See the individual fields for the types contained.
  */
-typedef struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ {
+typedef struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ {
    /**
-    * The contents of this CResult_NodeAnnouncementInfoDecodeErrorZ, accessible via either
-    * `err` or `result` depending on the state of `result_ok`.
+    * The element at position 0
     */
-   union LDKCResult_NodeAnnouncementInfoDecodeErrorZPtr contents;
+   struct LDKChannelAnnouncement a;
    /**
-    * Whether this CResult_NodeAnnouncementInfoDecodeErrorZ represents a success state.
+    * The element at position 1
     */
-   bool result_ok;
-} LDKCResult_NodeAnnouncementInfoDecodeErrorZ;
+   struct LDKChannelUpdate b;
+   /**
+    * The element at position 2
+    */
+   struct LDKChannelUpdate c;
+} LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ;
 
 /**
- * A dynamically-allocated array of u64s of arbitrary size.
+ * A dynamically-allocated array of crate::c_types::derived::C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZs of arbitrary size.
  * This corresponds to std::vector in C++
  */
-typedef struct LDKCVec_u64Z {
+typedef struct LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
    /**
     * The elements in the array.
     * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
     */
-   uint64_t *data;
+   struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *data;
    /**
     * The number of elements pointed to by `data`.
     */
    uintptr_t datalen;
-} LDKCVec_u64Z;
-
-
+} LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ;
 
 /**
- * Details about a node in the network, known from the network announcement.
+ * A dynamically-allocated array of crate::lightning::ln::msgs::NodeAnnouncements of arbitrary size.
+ * This corresponds to std::vector in C++
  */
-typedef struct MUST_USE_STRUCT LDKNodeInfo {
+typedef struct LDKCVec_NodeAnnouncementZ {
    /**
-    * A pointer to the opaque Rust object.
-    * Nearly everywhere, inner must be non-null, however in places where
-    * the Rust equivalent takes an Option, it may be set to null to indicate None.
+    * The elements in the array.
+    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
     */
-   LDKnativeNodeInfo *inner;
+   struct LDKNodeAnnouncement *data;
    /**
-    * Indicates that this is the only struct which contains the same pointer.
-    * Rust functions which take ownership of an object provided via an argument require
-    * this to be true and invalidate the object pointed to by inner.
+    * The number of elements pointed to by `data`.
     */
-   bool is_owned;
-} LDKNodeInfo;
+   uintptr_t datalen;
+} LDKCVec_NodeAnnouncementZ;
 
 /**
- * The contents of CResult_NodeInfoDecodeErrorZ
+ * The contents of CResult_NoneLightningErrorZ
  */
-typedef union LDKCResult_NodeInfoDecodeErrorZPtr {
+typedef union LDKCResult_NoneLightningErrorZPtr {
    /**
-    * A pointer to the contents in the success state.
-    * Reading from this pointer when `result_ok` is not set is undefined.
+    * Note that this value is always NULL, as there are no contents in the OK variant
     */
-   struct LDKNodeInfo *result;
+   void *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
-   struct LDKDecodeError *err;
-} LDKCResult_NodeInfoDecodeErrorZPtr;
+   struct LDKLightningError *err;
+} LDKCResult_NoneLightningErrorZPtr;
 
 /**
- * A CResult_NodeInfoDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::routing::network_graph::NodeInfo on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * A CResult_NoneLightningErrorZ represents the result of a fallible operation,
+ * containing a () on success and a crate::lightning::ln::msgs::LightningError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_NodeInfoDecodeErrorZ {
+typedef struct LDKCResult_NoneLightningErrorZ {
    /**
-    * The contents of this CResult_NodeInfoDecodeErrorZ, accessible via either
+    * The contents of this CResult_NoneLightningErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_NodeInfoDecodeErrorZPtr contents;
+   union LDKCResult_NoneLightningErrorZPtr contents;
    /**
-    * Whether this CResult_NodeInfoDecodeErrorZ represents a success state.
+    * Whether this CResult_NoneLightningErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_NodeInfoDecodeErrorZ;
+} LDKCResult_NoneLightningErrorZ;
+
+/**
+ * A dynamically-allocated array of crate::c_types::PublicKeys of arbitrary size.
+ * This corresponds to std::vector in C++
+ */
+typedef struct LDKCVec_PublicKeyZ {
+   /**
+    * The elements in the array.
+    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+    */
+   struct LDKPublicKey *data;
+   /**
+    * The number of elements pointed to by `data`.
+    */
+   uintptr_t datalen;
+} LDKCVec_PublicKeyZ;
 
 
 
 /**
- * Represents the network as nodes and channels between them
+ * Error for PeerManager errors. If you get one of these, you must disconnect the socket and
+ * generate no further read_event/write_buffer_space_avail/socket_disconnected calls for the
+ * descriptor.
  */
-typedef struct MUST_USE_STRUCT LDKNetworkGraph {
+typedef struct MUST_USE_STRUCT LDKPeerHandleError {
    /**
     * A pointer to the opaque Rust object.
     * Nearly everywhere, inner must be non-null, however in places where
     * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   LDKnativeNetworkGraph *inner;
+   LDKnativePeerHandleError *inner;
    /**
     * Indicates that this is the only struct which contains the same pointer.
     * Rust functions which take ownership of an object provided via an argument require
     * this to be true and invalidate the object pointed to by inner.
     */
    bool is_owned;
-} LDKNetworkGraph;
+} LDKPeerHandleError;
 
 /**
- * The contents of CResult_NetworkGraphDecodeErrorZ
+ * The contents of CResult_CVec_u8ZPeerHandleErrorZ
  */
-typedef union LDKCResult_NetworkGraphDecodeErrorZPtr {
+typedef union LDKCResult_CVec_u8ZPeerHandleErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKNetworkGraph *result;
+   struct LDKCVec_u8Z *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
-   struct LDKDecodeError *err;
-} LDKCResult_NetworkGraphDecodeErrorZPtr;
+   struct LDKPeerHandleError *err;
+} LDKCResult_CVec_u8ZPeerHandleErrorZPtr;
 
 /**
- * A CResult_NetworkGraphDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::routing::network_graph::NetworkGraph on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * A CResult_CVec_u8ZPeerHandleErrorZ represents the result of a fallible operation,
+ * containing a crate::c_types::derived::CVec_u8Z on success and a crate::lightning::ln::peer_handler::PeerHandleError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_NetworkGraphDecodeErrorZ {
+typedef struct LDKCResult_CVec_u8ZPeerHandleErrorZ {
    /**
-    * The contents of this CResult_NetworkGraphDecodeErrorZ, accessible via either
+    * The contents of this CResult_CVec_u8ZPeerHandleErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_NetworkGraphDecodeErrorZPtr contents;
+   union LDKCResult_CVec_u8ZPeerHandleErrorZPtr contents;
    /**
-    * Whether this CResult_NetworkGraphDecodeErrorZ represents a success state.
+    * Whether this CResult_CVec_u8ZPeerHandleErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_NetworkGraphDecodeErrorZ;
-
+} LDKCResult_CVec_u8ZPeerHandleErrorZ;
 
+/**
+ * The contents of CResult_NonePeerHandleErrorZ
+ */
+typedef union LDKCResult_NonePeerHandleErrorZPtr {
+   /**
+    * Note that this value is always NULL, as there are no contents in the OK variant
+    */
+   void *result;
+   /**
+    * A pointer to the contents in the error state.
+    * Reading from this pointer when `result_ok` is set is undefined.
+    */
+   struct LDKPeerHandleError *err;
+} LDKCResult_NonePeerHandleErrorZPtr;
 
 /**
- * Features used within an `init` message.
+ * A CResult_NonePeerHandleErrorZ represents the result of a fallible operation,
+ * containing a () on success and a crate::lightning::ln::peer_handler::PeerHandleError on failure.
+ * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct MUST_USE_STRUCT LDKInitFeatures {
+typedef struct LDKCResult_NonePeerHandleErrorZ {
    /**
-    * A pointer to the opaque Rust object.
-    * Nearly everywhere, inner must be non-null, however in places where
-    * the Rust equivalent takes an Option, it may be set to null to indicate None.
+    * The contents of this CResult_NonePeerHandleErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   LDKnativeInitFeatures *inner;
+   union LDKCResult_NonePeerHandleErrorZPtr contents;
    /**
-    * Indicates that this is the only struct which contains the same pointer.
-    * Rust functions which take ownership of an object provided via an argument require
-    * this to be true and invalidate the object pointed to by inner.
+    * Whether this CResult_NonePeerHandleErrorZ represents a success state.
     */
-   bool is_owned;
-} LDKInitFeatures;
+   bool result_ok;
+} LDKCResult_NonePeerHandleErrorZ;
 
 /**
- * The contents of CResult_InitFeaturesDecodeErrorZ
+ * The contents of CResult_boolPeerHandleErrorZ
  */
-typedef union LDKCResult_InitFeaturesDecodeErrorZPtr {
+typedef union LDKCResult_boolPeerHandleErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKInitFeatures *result;
+   bool *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
-   struct LDKDecodeError *err;
-} LDKCResult_InitFeaturesDecodeErrorZPtr;
+   struct LDKPeerHandleError *err;
+} LDKCResult_boolPeerHandleErrorZPtr;
 
 /**
- * A CResult_InitFeaturesDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::ln::features::InitFeatures on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * A CResult_boolPeerHandleErrorZ represents the result of a fallible operation,
+ * containing a bool on success and a crate::lightning::ln::peer_handler::PeerHandleError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_InitFeaturesDecodeErrorZ {
+typedef struct LDKCResult_boolPeerHandleErrorZ {
    /**
-    * The contents of this CResult_InitFeaturesDecodeErrorZ, accessible via either
+    * The contents of this CResult_boolPeerHandleErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_InitFeaturesDecodeErrorZPtr contents;
+   union LDKCResult_boolPeerHandleErrorZPtr contents;
    /**
-    * Whether this CResult_InitFeaturesDecodeErrorZ represents a success state.
+    * Whether this CResult_boolPeerHandleErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_InitFeaturesDecodeErrorZ;
-
-
-
-/**
- * Features used within a `node_announcement` message.
- */
-typedef struct MUST_USE_STRUCT LDKNodeFeatures {
-   /**
-    * A pointer to the opaque Rust object.
-    * Nearly everywhere, inner must be non-null, however in places where
-    * the Rust equivalent takes an Option, it may be set to null to indicate None.
-    */
-   LDKnativeNodeFeatures *inner;
-   /**
-    * Indicates that this is the only struct which contains the same pointer.
-    * Rust functions which take ownership of an object provided via an argument require
-    * this to be true and invalidate the object pointed to by inner.
-    */
-   bool is_owned;
-} LDKNodeFeatures;
+} LDKCResult_boolPeerHandleErrorZ;
 
 /**
- * The contents of CResult_NodeFeaturesDecodeErrorZ
+ * The contents of CResult_TxOutAccessErrorZ
  */
-typedef union LDKCResult_NodeFeaturesDecodeErrorZPtr {
+typedef union LDKCResult_TxOutAccessErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKNodeFeatures *result;
+   struct LDKTxOut *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
-   struct LDKDecodeError *err;
-} LDKCResult_NodeFeaturesDecodeErrorZPtr;
+   enum LDKAccessError *err;
+} LDKCResult_TxOutAccessErrorZPtr;
 
 /**
- * A CResult_NodeFeaturesDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::ln::features::NodeFeatures on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * A CResult_TxOutAccessErrorZ represents the result of a fallible operation,
+ * containing a crate::c_types::TxOut on success and a crate::lightning::chain::AccessError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_NodeFeaturesDecodeErrorZ {
+typedef struct LDKCResult_TxOutAccessErrorZ {
    /**
-    * The contents of this CResult_NodeFeaturesDecodeErrorZ, accessible via either
+    * The contents of this CResult_TxOutAccessErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_NodeFeaturesDecodeErrorZPtr contents;
+   union LDKCResult_TxOutAccessErrorZPtr contents;
    /**
-    * Whether this CResult_NodeFeaturesDecodeErrorZ represents a success state.
+    * Whether this CResult_TxOutAccessErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_NodeFeaturesDecodeErrorZ;
+} LDKCResult_TxOutAccessErrorZ;
+
+/**
+ * An enum which can either contain a crate::c_types::derived::C2Tuple_usizeTransactionZ or not
+ */
+typedef enum LDKCOption_C2Tuple_usizeTransactionZZ_Tag {
+   /**
+    * When we're in this state, this COption_C2Tuple_usizeTransactionZZ contains a crate::c_types::derived::C2Tuple_usizeTransactionZ
+    */
+   LDKCOption_C2Tuple_usizeTransactionZZ_Some,
+   /**
+    * When we're in this state, this COption_C2Tuple_usizeTransactionZZ contains nothing
+    */
+   LDKCOption_C2Tuple_usizeTransactionZZ_None,
+   /**
+    * Must be last for serialization purposes
+    */
+   LDKCOption_C2Tuple_usizeTransactionZZ_Sentinel,
+} LDKCOption_C2Tuple_usizeTransactionZZ_Tag;
+
+typedef struct LDKCOption_C2Tuple_usizeTransactionZZ {
+   LDKCOption_C2Tuple_usizeTransactionZZ_Tag tag;
+   union {
+      struct {
+         struct LDKC2Tuple_usizeTransactionZ some;
+      };
+   };
+} LDKCOption_C2Tuple_usizeTransactionZZ;
 
 
 
 /**
- * Features used within a `channel_announcement` message.
+ * Details about one direction of a channel. Received
+ * within a channel update.
  */
-typedef struct MUST_USE_STRUCT LDKChannelFeatures {
+typedef struct MUST_USE_STRUCT LDKDirectionalChannelInfo {
    /**
     * A pointer to the opaque Rust object.
     * Nearly everywhere, inner must be non-null, however in places where
     * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   LDKnativeChannelFeatures *inner;
+   LDKnativeDirectionalChannelInfo *inner;
    /**
     * Indicates that this is the only struct which contains the same pointer.
     * Rust functions which take ownership of an object provided via an argument require
     * this to be true and invalidate the object pointed to by inner.
     */
    bool is_owned;
-} LDKChannelFeatures;
+} LDKDirectionalChannelInfo;
 
 /**
- * The contents of CResult_ChannelFeaturesDecodeErrorZ
+ * The contents of CResult_DirectionalChannelInfoDecodeErrorZ
  */
-typedef union LDKCResult_ChannelFeaturesDecodeErrorZPtr {
+typedef union LDKCResult_DirectionalChannelInfoDecodeErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKChannelFeatures *result;
+   struct LDKDirectionalChannelInfo *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
    struct LDKDecodeError *err;
-} LDKCResult_ChannelFeaturesDecodeErrorZPtr;
+} LDKCResult_DirectionalChannelInfoDecodeErrorZPtr;
 
 /**
- * A CResult_ChannelFeaturesDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::ln::features::ChannelFeatures on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * A CResult_DirectionalChannelInfoDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::routing::network_graph::DirectionalChannelInfo on success and a crate::lightning::ln::msgs::DecodeError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_ChannelFeaturesDecodeErrorZ {
+typedef struct LDKCResult_DirectionalChannelInfoDecodeErrorZ {
    /**
-    * The contents of this CResult_ChannelFeaturesDecodeErrorZ, accessible via either
+    * The contents of this CResult_DirectionalChannelInfoDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_ChannelFeaturesDecodeErrorZPtr contents;
+   union LDKCResult_DirectionalChannelInfoDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_ChannelFeaturesDecodeErrorZ represents a success state.
+    * Whether this CResult_DirectionalChannelInfoDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_ChannelFeaturesDecodeErrorZ;
+} LDKCResult_DirectionalChannelInfoDecodeErrorZ;
 
 
 
 /**
- * Features used within an invoice.
+ * Details about a channel (both directions).
+ * Received within a channel announcement.
  */
-typedef struct MUST_USE_STRUCT LDKInvoiceFeatures {
+typedef struct MUST_USE_STRUCT LDKChannelInfo {
    /**
     * A pointer to the opaque Rust object.
     * Nearly everywhere, inner must be non-null, however in places where
     * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   LDKnativeInvoiceFeatures *inner;
+   LDKnativeChannelInfo *inner;
    /**
     * Indicates that this is the only struct which contains the same pointer.
     * Rust functions which take ownership of an object provided via an argument require
     * this to be true and invalidate the object pointed to by inner.
     */
    bool is_owned;
-} LDKInvoiceFeatures;
+} LDKChannelInfo;
 
 /**
- * The contents of CResult_InvoiceFeaturesDecodeErrorZ
+ * The contents of CResult_ChannelInfoDecodeErrorZ
  */
-typedef union LDKCResult_InvoiceFeaturesDecodeErrorZPtr {
+typedef union LDKCResult_ChannelInfoDecodeErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKInvoiceFeatures *result;
+   struct LDKChannelInfo *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
    struct LDKDecodeError *err;
-} LDKCResult_InvoiceFeaturesDecodeErrorZPtr;
+} LDKCResult_ChannelInfoDecodeErrorZPtr;
 
 /**
- * A CResult_InvoiceFeaturesDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::ln::features::InvoiceFeatures on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * A CResult_ChannelInfoDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::routing::network_graph::ChannelInfo on success and a crate::lightning::ln::msgs::DecodeError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_InvoiceFeaturesDecodeErrorZ {
+typedef struct LDKCResult_ChannelInfoDecodeErrorZ {
    /**
-    * The contents of this CResult_InvoiceFeaturesDecodeErrorZ, accessible via either
+    * The contents of this CResult_ChannelInfoDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_InvoiceFeaturesDecodeErrorZPtr contents;
+   union LDKCResult_ChannelInfoDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_InvoiceFeaturesDecodeErrorZ represents a success state.
+    * Whether this CResult_ChannelInfoDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_InvoiceFeaturesDecodeErrorZ;
+} LDKCResult_ChannelInfoDecodeErrorZ;
+
 
-/**
- * The contents of CResult_NetAddressu8Z
- */
-typedef union LDKCResult_NetAddressu8ZPtr {
-   /**
-    * A pointer to the contents in the success state.
-    * Reading from this pointer when `result_ok` is not set is undefined.
-    */
-   struct LDKNetAddress *result;
-   /**
-    * A pointer to the contents in the error state.
-    * Reading from this pointer when `result_ok` is set is undefined.
-    */
-   uint8_t *err;
-} LDKCResult_NetAddressu8ZPtr;
 
 /**
- * A CResult_NetAddressu8Z represents the result of a fallible operation,
- * containing a crate::lightning::ln::msgs::NetAddress on success and a u8 on failure.
- * `result_ok` indicates the overall state, and the contents are provided via `contents`.
+ * Fees for routing via a given channel or a node
  */
-typedef struct LDKCResult_NetAddressu8Z {
+typedef struct MUST_USE_STRUCT LDKRoutingFees {
    /**
-    * The contents of this CResult_NetAddressu8Z, accessible via either
-    * `err` or `result` depending on the state of `result_ok`.
+    * A pointer to the opaque Rust object.
+    * Nearly everywhere, inner must be non-null, however in places where
+    * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   union LDKCResult_NetAddressu8ZPtr contents;
+   LDKnativeRoutingFees *inner;
    /**
-    * Whether this CResult_NetAddressu8Z represents a success state.
+    * Indicates that this is the only struct which contains the same pointer.
+    * Rust functions which take ownership of an object provided via an argument require
+    * this to be true and invalidate the object pointed to by inner.
     */
-   bool result_ok;
-} LDKCResult_NetAddressu8Z;
+   bool is_owned;
+} LDKRoutingFees;
 
 /**
- * The contents of CResult_CResult_NetAddressu8ZDecodeErrorZ
+ * The contents of CResult_RoutingFeesDecodeErrorZ
  */
-typedef union LDKCResult_CResult_NetAddressu8ZDecodeErrorZPtr {
+typedef union LDKCResult_RoutingFeesDecodeErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKCResult_NetAddressu8Z *result;
+   struct LDKRoutingFees *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
    struct LDKDecodeError *err;
-} LDKCResult_CResult_NetAddressu8ZDecodeErrorZPtr;
+} LDKCResult_RoutingFeesDecodeErrorZPtr;
 
 /**
- * A CResult_CResult_NetAddressu8ZDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::c_types::derived::CResult_NetAddressu8Z on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * A CResult_RoutingFeesDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::routing::network_graph::RoutingFees on success and a crate::lightning::ln::msgs::DecodeError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_CResult_NetAddressu8ZDecodeErrorZ {
+typedef struct LDKCResult_RoutingFeesDecodeErrorZ {
    /**
-    * The contents of this CResult_CResult_NetAddressu8ZDecodeErrorZ, accessible via either
+    * The contents of this CResult_RoutingFeesDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_CResult_NetAddressu8ZDecodeErrorZPtr contents;
+   union LDKCResult_RoutingFeesDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_CResult_NetAddressu8ZDecodeErrorZ represents a success state.
+    * Whether this CResult_RoutingFeesDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_CResult_NetAddressu8ZDecodeErrorZ;
-
-
+} LDKCResult_RoutingFeesDecodeErrorZ;
 
 /**
- * An update_add_htlc message to be sent or received from a peer
+ * A 4-byte byte array.
  */
-typedef struct MUST_USE_STRUCT LDKUpdateAddHTLC {
-   /**
-    * A pointer to the opaque Rust object.
-    * Nearly everywhere, inner must be non-null, however in places where
-    * the Rust equivalent takes an Option, it may be set to null to indicate None.
-    */
-   LDKnativeUpdateAddHTLC *inner;
+typedef struct LDKFourBytes {
    /**
-    * Indicates that this is the only struct which contains the same pointer.
-    * Rust functions which take ownership of an object provided via an argument require
-    * this to be true and invalidate the object pointed to by inner.
+    * The four bytes
     */
-   bool is_owned;
-} LDKUpdateAddHTLC;
+   uint8_t data[4];
+} LDKFourBytes;
 
 /**
- * A dynamically-allocated array of crate::lightning::ln::msgs::UpdateAddHTLCs of arbitrary size.
- * This corresponds to std::vector in C++
+ * A 16-byte byte array.
  */
-typedef struct LDKCVec_UpdateAddHTLCZ {
+typedef struct LDKSixteenBytes {
    /**
-    * The elements in the array.
-    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+    * The sixteen bytes
     */
-   struct LDKUpdateAddHTLC *data;
+   uint8_t data[16];
+} LDKSixteenBytes;
+
+/**
+ * A 10-byte byte array.
+ */
+typedef struct LDKTenBytes {
    /**
-    * The number of elements pointed to by `data`.
+    * The ten bytes
     */
-   uintptr_t datalen;
-} LDKCVec_UpdateAddHTLCZ;
-
-
+   uint8_t data[10];
+} LDKTenBytes;
 
 /**
- * An update_fulfill_htlc message to be sent or received from a peer
+ * An address which can be used to connect to a remote peer
  */
-typedef struct MUST_USE_STRUCT LDKUpdateFulfillHTLC {
+typedef enum LDKNetAddress_Tag {
    /**
-    * A pointer to the opaque Rust object.
-    * Nearly everywhere, inner must be non-null, however in places where
-    * the Rust equivalent takes an Option, it may be set to null to indicate None.
+    * An IPv4 address/port on which the peer is listening.
     */
-   LDKnativeUpdateFulfillHTLC *inner;
+   LDKNetAddress_IPv4,
    /**
-    * Indicates that this is the only struct which contains the same pointer.
-    * Rust functions which take ownership of an object provided via an argument require
-    * this to be true and invalidate the object pointed to by inner.
+    * An IPv6 address/port on which the peer is listening.
     */
-   bool is_owned;
-} LDKUpdateFulfillHTLC;
-
-/**
- * A dynamically-allocated array of crate::lightning::ln::msgs::UpdateFulfillHTLCs of arbitrary size.
- * This corresponds to std::vector in C++
- */
-typedef struct LDKCVec_UpdateFulfillHTLCZ {
+   LDKNetAddress_IPv6,
    /**
-    * The elements in the array.
-    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+    * An old-style Tor onion address/port on which the peer is listening.
     */
-   struct LDKUpdateFulfillHTLC *data;
+   LDKNetAddress_OnionV2,
    /**
-    * The number of elements pointed to by `data`.
+    * A new-style Tor onion address/port on which the peer is listening.
+    * To create the human-readable \"hostname\", concatenate ed25519_pubkey, checksum, and version,
+    * wrap as base32 and append \".onion\".
     */
-   uintptr_t datalen;
-} LDKCVec_UpdateFulfillHTLCZ;
-
-
+   LDKNetAddress_OnionV3,
+   /**
+    * Must be last for serialization purposes
+    */
+   LDKNetAddress_Sentinel,
+} LDKNetAddress_Tag;
 
-/**
- * An update_fail_htlc message to be sent or received from a peer
- */
-typedef struct MUST_USE_STRUCT LDKUpdateFailHTLC {
+typedef struct LDKNetAddress_LDKIPv4_Body {
    /**
-    * A pointer to the opaque Rust object.
-    * Nearly everywhere, inner must be non-null, however in places where
-    * the Rust equivalent takes an Option, it may be set to null to indicate None.
+    * The 4-byte IPv4 address
     */
-   LDKnativeUpdateFailHTLC *inner;
+   struct LDKFourBytes addr;
    /**
-    * Indicates that this is the only struct which contains the same pointer.
-    * Rust functions which take ownership of an object provided via an argument require
-    * this to be true and invalidate the object pointed to by inner.
+    * The port on which the node is listening
     */
-   bool is_owned;
-} LDKUpdateFailHTLC;
+   uint16_t port;
+} LDKNetAddress_LDKIPv4_Body;
 
-/**
- * A dynamically-allocated array of crate::lightning::ln::msgs::UpdateFailHTLCs of arbitrary size.
+typedef struct LDKNetAddress_LDKIPv6_Body {
+   /**
+    * The 16-byte IPv6 address
+    */
+   struct LDKSixteenBytes addr;
+   /**
+    * The port on which the node is listening
+    */
+   uint16_t port;
+} LDKNetAddress_LDKIPv6_Body;
+
+typedef struct LDKNetAddress_LDKOnionV2_Body {
+   /**
+    * The bytes (usually encoded in base32 with \".onion\" appended)
+    */
+   struct LDKTenBytes addr;
+   /**
+    * The port on which the node is listening
+    */
+   uint16_t port;
+} LDKNetAddress_LDKOnionV2_Body;
+
+typedef struct LDKNetAddress_LDKOnionV3_Body {
+   /**
+    * The ed25519 long-term public key of the peer
+    */
+   struct LDKThirtyTwoBytes ed25519_pubkey;
+   /**
+    * The checksum of the pubkey and version, as included in the onion address
+    */
+   uint16_t checksum;
+   /**
+    * The version byte, as defined by the Tor Onion v3 spec.
+    */
+   uint8_t version;
+   /**
+    * The port on which the node is listening
+    */
+   uint16_t port;
+} LDKNetAddress_LDKOnionV3_Body;
+
+typedef struct MUST_USE_STRUCT LDKNetAddress {
+   LDKNetAddress_Tag tag;
+   union {
+      LDKNetAddress_LDKIPv4_Body i_pv4;
+      LDKNetAddress_LDKIPv6_Body i_pv6;
+      LDKNetAddress_LDKOnionV2_Body onion_v2;
+      LDKNetAddress_LDKOnionV3_Body onion_v3;
+   };
+} LDKNetAddress;
+
+/**
+ * A dynamically-allocated array of crate::lightning::ln::msgs::NetAddresss of arbitrary size.
  * This corresponds to std::vector in C++
  */
-typedef struct LDKCVec_UpdateFailHTLCZ {
+typedef struct LDKCVec_NetAddressZ {
    /**
     * The elements in the array.
     * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
     */
-   struct LDKUpdateFailHTLC *data;
+   struct LDKNetAddress *data;
    /**
     * The number of elements pointed to by `data`.
     */
    uintptr_t datalen;
-} LDKCVec_UpdateFailHTLCZ;
+} LDKCVec_NetAddressZ;
 
 
 
 /**
- * An update_fail_malformed_htlc message to be sent or received from a peer
+ * Information received in the latest node_announcement from this node.
  */
-typedef struct MUST_USE_STRUCT LDKUpdateFailMalformedHTLC {
+typedef struct MUST_USE_STRUCT LDKNodeAnnouncementInfo {
    /**
     * A pointer to the opaque Rust object.
     * Nearly everywhere, inner must be non-null, however in places where
     * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   LDKnativeUpdateFailMalformedHTLC *inner;
+   LDKnativeNodeAnnouncementInfo *inner;
    /**
     * Indicates that this is the only struct which contains the same pointer.
     * Rust functions which take ownership of an object provided via an argument require
     * this to be true and invalidate the object pointed to by inner.
     */
    bool is_owned;
-} LDKUpdateFailMalformedHTLC;
-
-/**
- * A dynamically-allocated array of crate::lightning::ln::msgs::UpdateFailMalformedHTLCs of arbitrary size.
- * This corresponds to std::vector in C++
- */
-typedef struct LDKCVec_UpdateFailMalformedHTLCZ {
-   /**
-    * The elements in the array.
-    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
-    */
-   struct LDKUpdateFailMalformedHTLC *data;
-   /**
-    * The number of elements pointed to by `data`.
-    */
-   uintptr_t datalen;
-} LDKCVec_UpdateFailMalformedHTLCZ;
+} LDKNodeAnnouncementInfo;
 
 /**
- * The contents of CResult_AcceptChannelDecodeErrorZ
+ * The contents of CResult_NodeAnnouncementInfoDecodeErrorZ
  */
-typedef union LDKCResult_AcceptChannelDecodeErrorZPtr {
+typedef union LDKCResult_NodeAnnouncementInfoDecodeErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKAcceptChannel *result;
+   struct LDKNodeAnnouncementInfo *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
    struct LDKDecodeError *err;
-} LDKCResult_AcceptChannelDecodeErrorZPtr;
+} LDKCResult_NodeAnnouncementInfoDecodeErrorZPtr;
 
 /**
- * A CResult_AcceptChannelDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::ln::msgs::AcceptChannel on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * A CResult_NodeAnnouncementInfoDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::routing::network_graph::NodeAnnouncementInfo on success and a crate::lightning::ln::msgs::DecodeError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_AcceptChannelDecodeErrorZ {
+typedef struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ {
    /**
-    * The contents of this CResult_AcceptChannelDecodeErrorZ, accessible via either
+    * The contents of this CResult_NodeAnnouncementInfoDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_AcceptChannelDecodeErrorZPtr contents;
+   union LDKCResult_NodeAnnouncementInfoDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_AcceptChannelDecodeErrorZ represents a success state.
+    * Whether this CResult_NodeAnnouncementInfoDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_AcceptChannelDecodeErrorZ;
+} LDKCResult_NodeAnnouncementInfoDecodeErrorZ;
 
 /**
- * The contents of CResult_AnnouncementSignaturesDecodeErrorZ
+ * A dynamically-allocated array of u64s of arbitrary size.
+ * This corresponds to std::vector in C++
  */
-typedef union LDKCResult_AnnouncementSignaturesDecodeErrorZPtr {
+typedef struct LDKCVec_u64Z {
    /**
-    * A pointer to the contents in the success state.
-    * Reading from this pointer when `result_ok` is not set is undefined.
+    * The elements in the array.
+    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
     */
-   struct LDKAnnouncementSignatures *result;
+   uint64_t *data;
    /**
-    * A pointer to the contents in the error state.
-    * Reading from this pointer when `result_ok` is set is undefined.
+    * The number of elements pointed to by `data`.
     */
-   struct LDKDecodeError *err;
-} LDKCResult_AnnouncementSignaturesDecodeErrorZPtr;
+   uintptr_t datalen;
+} LDKCVec_u64Z;
+
+
 
 /**
- * A CResult_AnnouncementSignaturesDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::ln::msgs::AnnouncementSignatures on success and a crate::lightning::ln::msgs::DecodeError on failure.
- * `result_ok` indicates the overall state, and the contents are provided via `contents`.
+ * Details about a node in the network, known from the network announcement.
  */
-typedef struct LDKCResult_AnnouncementSignaturesDecodeErrorZ {
+typedef struct MUST_USE_STRUCT LDKNodeInfo {
    /**
-    * The contents of this CResult_AnnouncementSignaturesDecodeErrorZ, accessible via either
-    * `err` or `result` depending on the state of `result_ok`.
+    * A pointer to the opaque Rust object.
+    * Nearly everywhere, inner must be non-null, however in places where
+    * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   union LDKCResult_AnnouncementSignaturesDecodeErrorZPtr contents;
+   LDKnativeNodeInfo *inner;
    /**
-    * Whether this CResult_AnnouncementSignaturesDecodeErrorZ represents a success state.
+    * Indicates that this is the only struct which contains the same pointer.
+    * Rust functions which take ownership of an object provided via an argument require
+    * this to be true and invalidate the object pointed to by inner.
     */
-   bool result_ok;
-} LDKCResult_AnnouncementSignaturesDecodeErrorZ;
+   bool is_owned;
+} LDKNodeInfo;
 
 /**
- * The contents of CResult_ChannelReestablishDecodeErrorZ
+ * The contents of CResult_NodeInfoDecodeErrorZ
  */
-typedef union LDKCResult_ChannelReestablishDecodeErrorZPtr {
+typedef union LDKCResult_NodeInfoDecodeErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKChannelReestablish *result;
+   struct LDKNodeInfo *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
    struct LDKDecodeError *err;
-} LDKCResult_ChannelReestablishDecodeErrorZPtr;
+} LDKCResult_NodeInfoDecodeErrorZPtr;
 
 /**
- * A CResult_ChannelReestablishDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::ln::msgs::ChannelReestablish on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * A CResult_NodeInfoDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::routing::network_graph::NodeInfo on success and a crate::lightning::ln::msgs::DecodeError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_ChannelReestablishDecodeErrorZ {
+typedef struct LDKCResult_NodeInfoDecodeErrorZ {
    /**
-    * The contents of this CResult_ChannelReestablishDecodeErrorZ, accessible via either
+    * The contents of this CResult_NodeInfoDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_ChannelReestablishDecodeErrorZPtr contents;
+   union LDKCResult_NodeInfoDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_ChannelReestablishDecodeErrorZ represents a success state.
+    * Whether this CResult_NodeInfoDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_ChannelReestablishDecodeErrorZ;
+} LDKCResult_NodeInfoDecodeErrorZ;
+
+
 
 /**
- * The contents of CResult_ClosingSignedDecodeErrorZ
+ * Represents the network as nodes and channels between them
  */
-typedef union LDKCResult_ClosingSignedDecodeErrorZPtr {
+typedef struct MUST_USE_STRUCT LDKNetworkGraph {
+   /**
+    * A pointer to the opaque Rust object.
+    * Nearly everywhere, inner must be non-null, however in places where
+    * the Rust equivalent takes an Option, it may be set to null to indicate None.
+    */
+   LDKnativeNetworkGraph *inner;
+   /**
+    * Indicates that this is the only struct which contains the same pointer.
+    * Rust functions which take ownership of an object provided via an argument require
+    * this to be true and invalidate the object pointed to by inner.
+    */
+   bool is_owned;
+} LDKNetworkGraph;
+
+/**
+ * The contents of CResult_NetworkGraphDecodeErrorZ
+ */
+typedef union LDKCResult_NetworkGraphDecodeErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKClosingSigned *result;
+   struct LDKNetworkGraph *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
    struct LDKDecodeError *err;
-} LDKCResult_ClosingSignedDecodeErrorZPtr;
+} LDKCResult_NetworkGraphDecodeErrorZPtr;
 
 /**
- * A CResult_ClosingSignedDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::ln::msgs::ClosingSigned on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * A CResult_NetworkGraphDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::routing::network_graph::NetworkGraph on success and a crate::lightning::ln::msgs::DecodeError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_ClosingSignedDecodeErrorZ {
+typedef struct LDKCResult_NetworkGraphDecodeErrorZ {
    /**
-    * The contents of this CResult_ClosingSignedDecodeErrorZ, accessible via either
+    * The contents of this CResult_NetworkGraphDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_ClosingSignedDecodeErrorZPtr contents;
+   union LDKCResult_NetworkGraphDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_ClosingSignedDecodeErrorZ represents a success state.
+    * Whether this CResult_NetworkGraphDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_ClosingSignedDecodeErrorZ;
+} LDKCResult_NetworkGraphDecodeErrorZ;
 
 
 
 /**
- * A commitment_signed message to be sent or received from a peer
+ * Features used within an `init` message.
  */
-typedef struct MUST_USE_STRUCT LDKCommitmentSigned {
+typedef struct MUST_USE_STRUCT LDKInitFeatures {
    /**
     * A pointer to the opaque Rust object.
     * Nearly everywhere, inner must be non-null, however in places where
     * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   LDKnativeCommitmentSigned *inner;
+   LDKnativeInitFeatures *inner;
    /**
     * Indicates that this is the only struct which contains the same pointer.
     * Rust functions which take ownership of an object provided via an argument require
     * this to be true and invalidate the object pointed to by inner.
     */
    bool is_owned;
-} LDKCommitmentSigned;
+} LDKInitFeatures;
 
 /**
- * The contents of CResult_CommitmentSignedDecodeErrorZ
+ * The contents of CResult_InitFeaturesDecodeErrorZ
  */
-typedef union LDKCResult_CommitmentSignedDecodeErrorZPtr {
+typedef union LDKCResult_InitFeaturesDecodeErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKCommitmentSigned *result;
+   struct LDKInitFeatures *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
    struct LDKDecodeError *err;
-} LDKCResult_CommitmentSignedDecodeErrorZPtr;
+} LDKCResult_InitFeaturesDecodeErrorZPtr;
 
 /**
- * A CResult_CommitmentSignedDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::ln::msgs::CommitmentSigned on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * A CResult_InitFeaturesDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::ln::features::InitFeatures on success and a crate::lightning::ln::msgs::DecodeError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_CommitmentSignedDecodeErrorZ {
+typedef struct LDKCResult_InitFeaturesDecodeErrorZ {
    /**
-    * The contents of this CResult_CommitmentSignedDecodeErrorZ, accessible via either
+    * The contents of this CResult_InitFeaturesDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_CommitmentSignedDecodeErrorZPtr contents;
+   union LDKCResult_InitFeaturesDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_CommitmentSignedDecodeErrorZ represents a success state.
+    * Whether this CResult_InitFeaturesDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_CommitmentSignedDecodeErrorZ;
+} LDKCResult_InitFeaturesDecodeErrorZ;
+
+
 
 /**
- * The contents of CResult_FundingCreatedDecodeErrorZ
+ * Features used within a `node_announcement` message.
  */
-typedef union LDKCResult_FundingCreatedDecodeErrorZPtr {
+typedef struct MUST_USE_STRUCT LDKNodeFeatures {
    /**
-    * A pointer to the contents in the success state.
-    * Reading from this pointer when `result_ok` is not set is undefined.
+    * A pointer to the opaque Rust object.
+    * Nearly everywhere, inner must be non-null, however in places where
+    * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   struct LDKFundingCreated *result;
+   LDKnativeNodeFeatures *inner;
    /**
-    * A pointer to the contents in the error state.
-    * Reading from this pointer when `result_ok` is set is undefined.
-    */
-   struct LDKDecodeError *err;
-} LDKCResult_FundingCreatedDecodeErrorZPtr;
-
-/**
- * A CResult_FundingCreatedDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::ln::msgs::FundingCreated on success and a crate::lightning::ln::msgs::DecodeError on failure.
- * `result_ok` indicates the overall state, and the contents are provided via `contents`.
- */
-typedef struct LDKCResult_FundingCreatedDecodeErrorZ {
-   /**
-    * The contents of this CResult_FundingCreatedDecodeErrorZ, accessible via either
-    * `err` or `result` depending on the state of `result_ok`.
-    */
-   union LDKCResult_FundingCreatedDecodeErrorZPtr contents;
-   /**
-    * Whether this CResult_FundingCreatedDecodeErrorZ represents a success state.
-    */
-   bool result_ok;
-} LDKCResult_FundingCreatedDecodeErrorZ;
-
-/**
- * The contents of CResult_FundingSignedDecodeErrorZ
- */
-typedef union LDKCResult_FundingSignedDecodeErrorZPtr {
-   /**
-    * A pointer to the contents in the success state.
-    * Reading from this pointer when `result_ok` is not set is undefined.
-    */
-   struct LDKFundingSigned *result;
-   /**
-    * A pointer to the contents in the error state.
-    * Reading from this pointer when `result_ok` is set is undefined.
-    */
-   struct LDKDecodeError *err;
-} LDKCResult_FundingSignedDecodeErrorZPtr;
-
-/**
- * A CResult_FundingSignedDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::ln::msgs::FundingSigned on success and a crate::lightning::ln::msgs::DecodeError on failure.
- * `result_ok` indicates the overall state, and the contents are provided via `contents`.
- */
-typedef struct LDKCResult_FundingSignedDecodeErrorZ {
-   /**
-    * The contents of this CResult_FundingSignedDecodeErrorZ, accessible via either
-    * `err` or `result` depending on the state of `result_ok`.
-    */
-   union LDKCResult_FundingSignedDecodeErrorZPtr contents;
-   /**
-    * Whether this CResult_FundingSignedDecodeErrorZ represents a success state.
+    * Indicates that this is the only struct which contains the same pointer.
+    * Rust functions which take ownership of an object provided via an argument require
+    * this to be true and invalidate the object pointed to by inner.
     */
-   bool result_ok;
-} LDKCResult_FundingSignedDecodeErrorZ;
+   bool is_owned;
+} LDKNodeFeatures;
 
 /**
- * The contents of CResult_FundingLockedDecodeErrorZ
+ * The contents of CResult_NodeFeaturesDecodeErrorZ
  */
-typedef union LDKCResult_FundingLockedDecodeErrorZPtr {
+typedef union LDKCResult_NodeFeaturesDecodeErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKFundingLocked *result;
+   struct LDKNodeFeatures *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
    struct LDKDecodeError *err;
-} LDKCResult_FundingLockedDecodeErrorZPtr;
+} LDKCResult_NodeFeaturesDecodeErrorZPtr;
 
 /**
- * A CResult_FundingLockedDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::ln::msgs::FundingLocked on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * A CResult_NodeFeaturesDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::ln::features::NodeFeatures on success and a crate::lightning::ln::msgs::DecodeError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_FundingLockedDecodeErrorZ {
+typedef struct LDKCResult_NodeFeaturesDecodeErrorZ {
    /**
-    * The contents of this CResult_FundingLockedDecodeErrorZ, accessible via either
+    * The contents of this CResult_NodeFeaturesDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_FundingLockedDecodeErrorZPtr contents;
+   union LDKCResult_NodeFeaturesDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_FundingLockedDecodeErrorZ represents a success state.
+    * Whether this CResult_NodeFeaturesDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_FundingLockedDecodeErrorZ;
+} LDKCResult_NodeFeaturesDecodeErrorZ;
 
 
 
 /**
- * An init message to be sent or received from a peer
+ * Features used within a `channel_announcement` message.
  */
-typedef struct MUST_USE_STRUCT LDKInit {
+typedef struct MUST_USE_STRUCT LDKChannelFeatures {
    /**
     * A pointer to the opaque Rust object.
     * Nearly everywhere, inner must be non-null, however in places where
     * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   LDKnativeInit *inner;
+   LDKnativeChannelFeatures *inner;
    /**
     * Indicates that this is the only struct which contains the same pointer.
     * Rust functions which take ownership of an object provided via an argument require
     * this to be true and invalidate the object pointed to by inner.
     */
    bool is_owned;
-} LDKInit;
+} LDKChannelFeatures;
 
 /**
- * The contents of CResult_InitDecodeErrorZ
+ * The contents of CResult_ChannelFeaturesDecodeErrorZ
  */
-typedef union LDKCResult_InitDecodeErrorZPtr {
+typedef union LDKCResult_ChannelFeaturesDecodeErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKInit *result;
+   struct LDKChannelFeatures *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
    struct LDKDecodeError *err;
-} LDKCResult_InitDecodeErrorZPtr;
+} LDKCResult_ChannelFeaturesDecodeErrorZPtr;
 
 /**
- * A CResult_InitDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::ln::msgs::Init on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * A CResult_ChannelFeaturesDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::ln::features::ChannelFeatures on success and a crate::lightning::ln::msgs::DecodeError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_InitDecodeErrorZ {
+typedef struct LDKCResult_ChannelFeaturesDecodeErrorZ {
    /**
-    * The contents of this CResult_InitDecodeErrorZ, accessible via either
+    * The contents of this CResult_ChannelFeaturesDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_InitDecodeErrorZPtr contents;
+   union LDKCResult_ChannelFeaturesDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_InitDecodeErrorZ represents a success state.
+    * Whether this CResult_ChannelFeaturesDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_InitDecodeErrorZ;
+} LDKCResult_ChannelFeaturesDecodeErrorZ;
 
 /**
- * The contents of CResult_OpenChannelDecodeErrorZ
+ * The contents of CResult_InvoiceFeaturesDecodeErrorZ
  */
-typedef union LDKCResult_OpenChannelDecodeErrorZPtr {
+typedef union LDKCResult_InvoiceFeaturesDecodeErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKOpenChannel *result;
+   struct LDKInvoiceFeatures *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
    struct LDKDecodeError *err;
-} LDKCResult_OpenChannelDecodeErrorZPtr;
+} LDKCResult_InvoiceFeaturesDecodeErrorZPtr;
 
 /**
- * A CResult_OpenChannelDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::ln::msgs::OpenChannel on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * A CResult_InvoiceFeaturesDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::ln::features::InvoiceFeatures on success and a crate::lightning::ln::msgs::DecodeError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_OpenChannelDecodeErrorZ {
+typedef struct LDKCResult_InvoiceFeaturesDecodeErrorZ {
    /**
-    * The contents of this CResult_OpenChannelDecodeErrorZ, accessible via either
+    * The contents of this CResult_InvoiceFeaturesDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_OpenChannelDecodeErrorZPtr contents;
+   union LDKCResult_InvoiceFeaturesDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_OpenChannelDecodeErrorZ represents a success state.
+    * Whether this CResult_InvoiceFeaturesDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_OpenChannelDecodeErrorZ;
+} LDKCResult_InvoiceFeaturesDecodeErrorZ;
 
 /**
- * The contents of CResult_RevokeAndACKDecodeErrorZ
+ * The contents of CResult_NetAddressu8Z
  */
-typedef union LDKCResult_RevokeAndACKDecodeErrorZPtr {
+typedef union LDKCResult_NetAddressu8ZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKRevokeAndACK *result;
+   struct LDKNetAddress *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
-   struct LDKDecodeError *err;
-} LDKCResult_RevokeAndACKDecodeErrorZPtr;
+   uint8_t *err;
+} LDKCResult_NetAddressu8ZPtr;
 
 /**
- * A CResult_RevokeAndACKDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::ln::msgs::RevokeAndACK on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * A CResult_NetAddressu8Z represents the result of a fallible operation,
+ * containing a crate::lightning::ln::msgs::NetAddress on success and a u8 on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_RevokeAndACKDecodeErrorZ {
+typedef struct LDKCResult_NetAddressu8Z {
    /**
-    * The contents of this CResult_RevokeAndACKDecodeErrorZ, accessible via either
+    * The contents of this CResult_NetAddressu8Z, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_RevokeAndACKDecodeErrorZPtr contents;
+   union LDKCResult_NetAddressu8ZPtr contents;
    /**
-    * Whether this CResult_RevokeAndACKDecodeErrorZ represents a success state.
+    * Whether this CResult_NetAddressu8Z represents a success state.
     */
    bool result_ok;
-} LDKCResult_RevokeAndACKDecodeErrorZ;
+} LDKCResult_NetAddressu8Z;
 
 /**
- * The contents of CResult_ShutdownDecodeErrorZ
+ * The contents of CResult_CResult_NetAddressu8ZDecodeErrorZ
  */
-typedef union LDKCResult_ShutdownDecodeErrorZPtr {
+typedef union LDKCResult_CResult_NetAddressu8ZDecodeErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKShutdown *result;
+   struct LDKCResult_NetAddressu8Z *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
    struct LDKDecodeError *err;
-} LDKCResult_ShutdownDecodeErrorZPtr;
+} LDKCResult_CResult_NetAddressu8ZDecodeErrorZPtr;
 
 /**
- * A CResult_ShutdownDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::ln::msgs::Shutdown on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * A CResult_CResult_NetAddressu8ZDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::c_types::derived::CResult_NetAddressu8Z on success and a crate::lightning::ln::msgs::DecodeError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_ShutdownDecodeErrorZ {
+typedef struct LDKCResult_CResult_NetAddressu8ZDecodeErrorZ {
    /**
-    * The contents of this CResult_ShutdownDecodeErrorZ, accessible via either
+    * The contents of this CResult_CResult_NetAddressu8ZDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_ShutdownDecodeErrorZPtr contents;
+   union LDKCResult_CResult_NetAddressu8ZDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_ShutdownDecodeErrorZ represents a success state.
+    * Whether this CResult_CResult_NetAddressu8ZDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_ShutdownDecodeErrorZ;
+} LDKCResult_CResult_NetAddressu8ZDecodeErrorZ;
 
-/**
- * The contents of CResult_UpdateFailHTLCDecodeErrorZ
- */
-typedef union LDKCResult_UpdateFailHTLCDecodeErrorZPtr {
-   /**
-    * A pointer to the contents in the success state.
-    * Reading from this pointer when `result_ok` is not set is undefined.
-    */
-   struct LDKUpdateFailHTLC *result;
-   /**
-    * A pointer to the contents in the error state.
-    * Reading from this pointer when `result_ok` is set is undefined.
-    */
-   struct LDKDecodeError *err;
-} LDKCResult_UpdateFailHTLCDecodeErrorZPtr;
 
-/**
- * A CResult_UpdateFailHTLCDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::ln::msgs::UpdateFailHTLC on success and a crate::lightning::ln::msgs::DecodeError on failure.
- * `result_ok` indicates the overall state, and the contents are provided via `contents`.
- */
-typedef struct LDKCResult_UpdateFailHTLCDecodeErrorZ {
-   /**
-    * The contents of this CResult_UpdateFailHTLCDecodeErrorZ, accessible via either
-    * `err` or `result` depending on the state of `result_ok`.
-    */
-   union LDKCResult_UpdateFailHTLCDecodeErrorZPtr contents;
-   /**
-    * Whether this CResult_UpdateFailHTLCDecodeErrorZ represents a success state.
-    */
-   bool result_ok;
-} LDKCResult_UpdateFailHTLCDecodeErrorZ;
 
 /**
- * The contents of CResult_UpdateFailMalformedHTLCDecodeErrorZ
+ * An update_add_htlc message to be sent or received from a peer
  */
-typedef union LDKCResult_UpdateFailMalformedHTLCDecodeErrorZPtr {
+typedef struct MUST_USE_STRUCT LDKUpdateAddHTLC {
    /**
-    * A pointer to the contents in the success state.
-    * Reading from this pointer when `result_ok` is not set is undefined.
+    * A pointer to the opaque Rust object.
+    * Nearly everywhere, inner must be non-null, however in places where
+    * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   struct LDKUpdateFailMalformedHTLC *result;
+   LDKnativeUpdateAddHTLC *inner;
    /**
-    * A pointer to the contents in the error state.
-    * Reading from this pointer when `result_ok` is set is undefined.
+    * Indicates that this is the only struct which contains the same pointer.
+    * Rust functions which take ownership of an object provided via an argument require
+    * this to be true and invalidate the object pointed to by inner.
     */
-   struct LDKDecodeError *err;
-} LDKCResult_UpdateFailMalformedHTLCDecodeErrorZPtr;
+   bool is_owned;
+} LDKUpdateAddHTLC;
 
 /**
- * A CResult_UpdateFailMalformedHTLCDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::ln::msgs::UpdateFailMalformedHTLC on success and a crate::lightning::ln::msgs::DecodeError on failure.
- * `result_ok` indicates the overall state, and the contents are provided via `contents`.
+ * A dynamically-allocated array of crate::lightning::ln::msgs::UpdateAddHTLCs of arbitrary size.
+ * This corresponds to std::vector in C++
  */
-typedef struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ {
+typedef struct LDKCVec_UpdateAddHTLCZ {
    /**
-    * The contents of this CResult_UpdateFailMalformedHTLCDecodeErrorZ, accessible via either
-    * `err` or `result` depending on the state of `result_ok`.
+    * The elements in the array.
+    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
     */
-   union LDKCResult_UpdateFailMalformedHTLCDecodeErrorZPtr contents;
+   struct LDKUpdateAddHTLC *data;
    /**
-    * Whether this CResult_UpdateFailMalformedHTLCDecodeErrorZ represents a success state.
+    * The number of elements pointed to by `data`.
     */
-   bool result_ok;
-} LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ;
+   uintptr_t datalen;
+} LDKCVec_UpdateAddHTLCZ;
 
 
 
 /**
- * An update_fee message to be sent or received from a peer
+ * An update_fulfill_htlc message to be sent or received from a peer
  */
-typedef struct MUST_USE_STRUCT LDKUpdateFee {
+typedef struct MUST_USE_STRUCT LDKUpdateFulfillHTLC {
    /**
     * A pointer to the opaque Rust object.
     * Nearly everywhere, inner must be non-null, however in places where
     * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   LDKnativeUpdateFee *inner;
+   LDKnativeUpdateFulfillHTLC *inner;
    /**
     * Indicates that this is the only struct which contains the same pointer.
     * Rust functions which take ownership of an object provided via an argument require
     * this to be true and invalidate the object pointed to by inner.
     */
    bool is_owned;
-} LDKUpdateFee;
+} LDKUpdateFulfillHTLC;
 
 /**
- * The contents of CResult_UpdateFeeDecodeErrorZ
+ * A dynamically-allocated array of crate::lightning::ln::msgs::UpdateFulfillHTLCs of arbitrary size.
+ * This corresponds to std::vector in C++
  */
-typedef union LDKCResult_UpdateFeeDecodeErrorZPtr {
+typedef struct LDKCVec_UpdateFulfillHTLCZ {
    /**
-    * A pointer to the contents in the success state.
-    * Reading from this pointer when `result_ok` is not set is undefined.
+    * The elements in the array.
+    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
     */
-   struct LDKUpdateFee *result;
+   struct LDKUpdateFulfillHTLC *data;
    /**
-    * A pointer to the contents in the error state.
-    * Reading from this pointer when `result_ok` is set is undefined.
+    * The number of elements pointed to by `data`.
     */
-   struct LDKDecodeError *err;
-} LDKCResult_UpdateFeeDecodeErrorZPtr;
+   uintptr_t datalen;
+} LDKCVec_UpdateFulfillHTLCZ;
+
+
 
 /**
- * A CResult_UpdateFeeDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::ln::msgs::UpdateFee on success and a crate::lightning::ln::msgs::DecodeError on failure.
- * `result_ok` indicates the overall state, and the contents are provided via `contents`.
+ * An update_fail_htlc message to be sent or received from a peer
  */
-typedef struct LDKCResult_UpdateFeeDecodeErrorZ {
+typedef struct MUST_USE_STRUCT LDKUpdateFailHTLC {
    /**
-    * The contents of this CResult_UpdateFeeDecodeErrorZ, accessible via either
-    * `err` or `result` depending on the state of `result_ok`.
+    * A pointer to the opaque Rust object.
+    * Nearly everywhere, inner must be non-null, however in places where
+    * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   union LDKCResult_UpdateFeeDecodeErrorZPtr contents;
+   LDKnativeUpdateFailHTLC *inner;
    /**
-    * Whether this CResult_UpdateFeeDecodeErrorZ represents a success state.
+    * Indicates that this is the only struct which contains the same pointer.
+    * Rust functions which take ownership of an object provided via an argument require
+    * this to be true and invalidate the object pointed to by inner.
     */
-   bool result_ok;
-} LDKCResult_UpdateFeeDecodeErrorZ;
+   bool is_owned;
+} LDKUpdateFailHTLC;
 
 /**
- * The contents of CResult_UpdateFulfillHTLCDecodeErrorZ
+ * A dynamically-allocated array of crate::lightning::ln::msgs::UpdateFailHTLCs of arbitrary size.
+ * This corresponds to std::vector in C++
  */
-typedef union LDKCResult_UpdateFulfillHTLCDecodeErrorZPtr {
+typedef struct LDKCVec_UpdateFailHTLCZ {
+   /**
+    * The elements in the array.
+    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+    */
+   struct LDKUpdateFailHTLC *data;
+   /**
+    * The number of elements pointed to by `data`.
+    */
+   uintptr_t datalen;
+} LDKCVec_UpdateFailHTLCZ;
+
+
+
+/**
+ * An update_fail_malformed_htlc message to be sent or received from a peer
+ */
+typedef struct MUST_USE_STRUCT LDKUpdateFailMalformedHTLC {
+   /**
+    * A pointer to the opaque Rust object.
+    * Nearly everywhere, inner must be non-null, however in places where
+    * the Rust equivalent takes an Option, it may be set to null to indicate None.
+    */
+   LDKnativeUpdateFailMalformedHTLC *inner;
+   /**
+    * Indicates that this is the only struct which contains the same pointer.
+    * Rust functions which take ownership of an object provided via an argument require
+    * this to be true and invalidate the object pointed to by inner.
+    */
+   bool is_owned;
+} LDKUpdateFailMalformedHTLC;
+
+/**
+ * A dynamically-allocated array of crate::lightning::ln::msgs::UpdateFailMalformedHTLCs of arbitrary size.
+ * This corresponds to std::vector in C++
+ */
+typedef struct LDKCVec_UpdateFailMalformedHTLCZ {
+   /**
+    * The elements in the array.
+    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+    */
+   struct LDKUpdateFailMalformedHTLC *data;
+   /**
+    * The number of elements pointed to by `data`.
+    */
+   uintptr_t datalen;
+} LDKCVec_UpdateFailMalformedHTLCZ;
+
+/**
+ * The contents of CResult_AcceptChannelDecodeErrorZ
+ */
+typedef union LDKCResult_AcceptChannelDecodeErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKUpdateFulfillHTLC *result;
+   struct LDKAcceptChannel *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
    struct LDKDecodeError *err;
-} LDKCResult_UpdateFulfillHTLCDecodeErrorZPtr;
+} LDKCResult_AcceptChannelDecodeErrorZPtr;
 
 /**
- * A CResult_UpdateFulfillHTLCDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::ln::msgs::UpdateFulfillHTLC on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * A CResult_AcceptChannelDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::ln::msgs::AcceptChannel on success and a crate::lightning::ln::msgs::DecodeError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ {
+typedef struct LDKCResult_AcceptChannelDecodeErrorZ {
    /**
-    * The contents of this CResult_UpdateFulfillHTLCDecodeErrorZ, accessible via either
+    * The contents of this CResult_AcceptChannelDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_UpdateFulfillHTLCDecodeErrorZPtr contents;
+   union LDKCResult_AcceptChannelDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_UpdateFulfillHTLCDecodeErrorZ represents a success state.
+    * Whether this CResult_AcceptChannelDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_UpdateFulfillHTLCDecodeErrorZ;
+} LDKCResult_AcceptChannelDecodeErrorZ;
 
 /**
- * The contents of CResult_UpdateAddHTLCDecodeErrorZ
+ * The contents of CResult_AnnouncementSignaturesDecodeErrorZ
  */
-typedef union LDKCResult_UpdateAddHTLCDecodeErrorZPtr {
+typedef union LDKCResult_AnnouncementSignaturesDecodeErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKUpdateAddHTLC *result;
+   struct LDKAnnouncementSignatures *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
    struct LDKDecodeError *err;
-} LDKCResult_UpdateAddHTLCDecodeErrorZPtr;
+} LDKCResult_AnnouncementSignaturesDecodeErrorZPtr;
 
 /**
- * A CResult_UpdateAddHTLCDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::ln::msgs::UpdateAddHTLC on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * A CResult_AnnouncementSignaturesDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::ln::msgs::AnnouncementSignatures on success and a crate::lightning::ln::msgs::DecodeError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_UpdateAddHTLCDecodeErrorZ {
+typedef struct LDKCResult_AnnouncementSignaturesDecodeErrorZ {
    /**
-    * The contents of this CResult_UpdateAddHTLCDecodeErrorZ, accessible via either
+    * The contents of this CResult_AnnouncementSignaturesDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_UpdateAddHTLCDecodeErrorZPtr contents;
+   union LDKCResult_AnnouncementSignaturesDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_UpdateAddHTLCDecodeErrorZ represents a success state.
+    * Whether this CResult_AnnouncementSignaturesDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_UpdateAddHTLCDecodeErrorZ;
-
+} LDKCResult_AnnouncementSignaturesDecodeErrorZ;
 
+/**
+ * The contents of CResult_ChannelReestablishDecodeErrorZ
+ */
+typedef union LDKCResult_ChannelReestablishDecodeErrorZPtr {
+   /**
+    * A pointer to the contents in the success state.
+    * Reading from this pointer when `result_ok` is not set is undefined.
+    */
+   struct LDKChannelReestablish *result;
+   /**
+    * A pointer to the contents in the error state.
+    * Reading from this pointer when `result_ok` is set is undefined.
+    */
+   struct LDKDecodeError *err;
+} LDKCResult_ChannelReestablishDecodeErrorZPtr;
 
 /**
- * A ping message to be sent or received from a peer
+ * A CResult_ChannelReestablishDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::ln::msgs::ChannelReestablish on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct MUST_USE_STRUCT LDKPing {
+typedef struct LDKCResult_ChannelReestablishDecodeErrorZ {
    /**
-    * A pointer to the opaque Rust object.
-    * Nearly everywhere, inner must be non-null, however in places where
-    * the Rust equivalent takes an Option, it may be set to null to indicate None.
+    * The contents of this CResult_ChannelReestablishDecodeErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   LDKnativePing *inner;
+   union LDKCResult_ChannelReestablishDecodeErrorZPtr contents;
    /**
-    * Indicates that this is the only struct which contains the same pointer.
-    * Rust functions which take ownership of an object provided via an argument require
-    * this to be true and invalidate the object pointed to by inner.
+    * Whether this CResult_ChannelReestablishDecodeErrorZ represents a success state.
     */
-   bool is_owned;
-} LDKPing;
+   bool result_ok;
+} LDKCResult_ChannelReestablishDecodeErrorZ;
 
 /**
- * The contents of CResult_PingDecodeErrorZ
+ * The contents of CResult_ClosingSignedDecodeErrorZ
  */
-typedef union LDKCResult_PingDecodeErrorZPtr {
+typedef union LDKCResult_ClosingSignedDecodeErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKPing *result;
+   struct LDKClosingSigned *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
    struct LDKDecodeError *err;
-} LDKCResult_PingDecodeErrorZPtr;
+} LDKCResult_ClosingSignedDecodeErrorZPtr;
 
 /**
- * A CResult_PingDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::ln::msgs::Ping on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * A CResult_ClosingSignedDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::ln::msgs::ClosingSigned on success and a crate::lightning::ln::msgs::DecodeError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_PingDecodeErrorZ {
+typedef struct LDKCResult_ClosingSignedDecodeErrorZ {
    /**
-    * The contents of this CResult_PingDecodeErrorZ, accessible via either
+    * The contents of this CResult_ClosingSignedDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_PingDecodeErrorZPtr contents;
+   union LDKCResult_ClosingSignedDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_PingDecodeErrorZ represents a success state.
+    * Whether this CResult_ClosingSignedDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_PingDecodeErrorZ;
+} LDKCResult_ClosingSignedDecodeErrorZ;
 
 
 
 /**
- * A pong message to be sent or received from a peer
+ * A commitment_signed message to be sent or received from a peer
  */
-typedef struct MUST_USE_STRUCT LDKPong {
+typedef struct MUST_USE_STRUCT LDKCommitmentSigned {
    /**
     * A pointer to the opaque Rust object.
     * Nearly everywhere, inner must be non-null, however in places where
     * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   LDKnativePong *inner;
+   LDKnativeCommitmentSigned *inner;
    /**
     * Indicates that this is the only struct which contains the same pointer.
     * Rust functions which take ownership of an object provided via an argument require
     * this to be true and invalidate the object pointed to by inner.
     */
    bool is_owned;
-} LDKPong;
+} LDKCommitmentSigned;
 
 /**
- * The contents of CResult_PongDecodeErrorZ
+ * The contents of CResult_CommitmentSignedDecodeErrorZ
  */
-typedef union LDKCResult_PongDecodeErrorZPtr {
+typedef union LDKCResult_CommitmentSignedDecodeErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKPong *result;
+   struct LDKCommitmentSigned *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
    struct LDKDecodeError *err;
-} LDKCResult_PongDecodeErrorZPtr;
+} LDKCResult_CommitmentSignedDecodeErrorZPtr;
 
 /**
- * A CResult_PongDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::ln::msgs::Pong on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * A CResult_CommitmentSignedDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::ln::msgs::CommitmentSigned on success and a crate::lightning::ln::msgs::DecodeError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_PongDecodeErrorZ {
+typedef struct LDKCResult_CommitmentSignedDecodeErrorZ {
    /**
-    * The contents of this CResult_PongDecodeErrorZ, accessible via either
+    * The contents of this CResult_CommitmentSignedDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_PongDecodeErrorZPtr contents;
+   union LDKCResult_CommitmentSignedDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_PongDecodeErrorZ represents a success state.
+    * Whether this CResult_CommitmentSignedDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_PongDecodeErrorZ;
+} LDKCResult_CommitmentSignedDecodeErrorZ;
 
 /**
- * The contents of CResult_UnsignedChannelAnnouncementDecodeErrorZ
+ * The contents of CResult_FundingCreatedDecodeErrorZ
  */
-typedef union LDKCResult_UnsignedChannelAnnouncementDecodeErrorZPtr {
+typedef union LDKCResult_FundingCreatedDecodeErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKUnsignedChannelAnnouncement *result;
+   struct LDKFundingCreated *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
    struct LDKDecodeError *err;
-} LDKCResult_UnsignedChannelAnnouncementDecodeErrorZPtr;
+} LDKCResult_FundingCreatedDecodeErrorZPtr;
 
 /**
- * A CResult_UnsignedChannelAnnouncementDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::ln::msgs::UnsignedChannelAnnouncement on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * A CResult_FundingCreatedDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::ln::msgs::FundingCreated on success and a crate::lightning::ln::msgs::DecodeError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ {
+typedef struct LDKCResult_FundingCreatedDecodeErrorZ {
    /**
-    * The contents of this CResult_UnsignedChannelAnnouncementDecodeErrorZ, accessible via either
+    * The contents of this CResult_FundingCreatedDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_UnsignedChannelAnnouncementDecodeErrorZPtr contents;
+   union LDKCResult_FundingCreatedDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_UnsignedChannelAnnouncementDecodeErrorZ represents a success state.
+    * Whether this CResult_FundingCreatedDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ;
+} LDKCResult_FundingCreatedDecodeErrorZ;
 
 /**
- * The contents of CResult_ChannelAnnouncementDecodeErrorZ
+ * The contents of CResult_FundingSignedDecodeErrorZ
  */
-typedef union LDKCResult_ChannelAnnouncementDecodeErrorZPtr {
+typedef union LDKCResult_FundingSignedDecodeErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKChannelAnnouncement *result;
+   struct LDKFundingSigned *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
    struct LDKDecodeError *err;
-} LDKCResult_ChannelAnnouncementDecodeErrorZPtr;
+} LDKCResult_FundingSignedDecodeErrorZPtr;
 
 /**
- * A CResult_ChannelAnnouncementDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::ln::msgs::ChannelAnnouncement on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * A CResult_FundingSignedDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::ln::msgs::FundingSigned on success and a crate::lightning::ln::msgs::DecodeError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_ChannelAnnouncementDecodeErrorZ {
+typedef struct LDKCResult_FundingSignedDecodeErrorZ {
    /**
-    * The contents of this CResult_ChannelAnnouncementDecodeErrorZ, accessible via either
+    * The contents of this CResult_FundingSignedDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_ChannelAnnouncementDecodeErrorZPtr contents;
+   union LDKCResult_FundingSignedDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_ChannelAnnouncementDecodeErrorZ represents a success state.
+    * Whether this CResult_FundingSignedDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_ChannelAnnouncementDecodeErrorZ;
+} LDKCResult_FundingSignedDecodeErrorZ;
+
+/**
+ * The contents of CResult_FundingLockedDecodeErrorZ
+ */
+typedef union LDKCResult_FundingLockedDecodeErrorZPtr {
+   /**
+    * A pointer to the contents in the success state.
+    * Reading from this pointer when `result_ok` is not set is undefined.
+    */
+   struct LDKFundingLocked *result;
+   /**
+    * A pointer to the contents in the error state.
+    * Reading from this pointer when `result_ok` is set is undefined.
+    */
+   struct LDKDecodeError *err;
+} LDKCResult_FundingLockedDecodeErrorZPtr;
+
+/**
+ * A CResult_FundingLockedDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::ln::msgs::FundingLocked on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * `result_ok` indicates the overall state, and the contents are provided via `contents`.
+ */
+typedef struct LDKCResult_FundingLockedDecodeErrorZ {
+   /**
+    * The contents of this CResult_FundingLockedDecodeErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
+    */
+   union LDKCResult_FundingLockedDecodeErrorZPtr contents;
+   /**
+    * Whether this CResult_FundingLockedDecodeErrorZ represents a success state.
+    */
+   bool result_ok;
+} LDKCResult_FundingLockedDecodeErrorZ;
 
 
 
 /**
- * The unsigned part of a channel_update
+ * An init message to be sent or received from a peer
  */
-typedef struct MUST_USE_STRUCT LDKUnsignedChannelUpdate {
+typedef struct MUST_USE_STRUCT LDKInit {
    /**
     * A pointer to the opaque Rust object.
     * Nearly everywhere, inner must be non-null, however in places where
     * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   LDKnativeUnsignedChannelUpdate *inner;
+   LDKnativeInit *inner;
    /**
     * Indicates that this is the only struct which contains the same pointer.
     * Rust functions which take ownership of an object provided via an argument require
     * this to be true and invalidate the object pointed to by inner.
     */
    bool is_owned;
-} LDKUnsignedChannelUpdate;
+} LDKInit;
 
 /**
- * The contents of CResult_UnsignedChannelUpdateDecodeErrorZ
+ * The contents of CResult_InitDecodeErrorZ
  */
-typedef union LDKCResult_UnsignedChannelUpdateDecodeErrorZPtr {
+typedef union LDKCResult_InitDecodeErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKUnsignedChannelUpdate *result;
+   struct LDKInit *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
    struct LDKDecodeError *err;
-} LDKCResult_UnsignedChannelUpdateDecodeErrorZPtr;
+} LDKCResult_InitDecodeErrorZPtr;
 
 /**
- * A CResult_UnsignedChannelUpdateDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::ln::msgs::UnsignedChannelUpdate on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * A CResult_InitDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::ln::msgs::Init on success and a crate::lightning::ln::msgs::DecodeError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ {
+typedef struct LDKCResult_InitDecodeErrorZ {
    /**
-    * The contents of this CResult_UnsignedChannelUpdateDecodeErrorZ, accessible via either
+    * The contents of this CResult_InitDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_UnsignedChannelUpdateDecodeErrorZPtr contents;
+   union LDKCResult_InitDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_UnsignedChannelUpdateDecodeErrorZ represents a success state.
+    * Whether this CResult_InitDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_UnsignedChannelUpdateDecodeErrorZ;
+} LDKCResult_InitDecodeErrorZ;
 
 /**
- * The contents of CResult_ChannelUpdateDecodeErrorZ
+ * The contents of CResult_OpenChannelDecodeErrorZ
  */
-typedef union LDKCResult_ChannelUpdateDecodeErrorZPtr {
+typedef union LDKCResult_OpenChannelDecodeErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKChannelUpdate *result;
+   struct LDKOpenChannel *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
    struct LDKDecodeError *err;
-} LDKCResult_ChannelUpdateDecodeErrorZPtr;
+} LDKCResult_OpenChannelDecodeErrorZPtr;
 
 /**
- * A CResult_ChannelUpdateDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::ln::msgs::ChannelUpdate on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * A CResult_OpenChannelDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::ln::msgs::OpenChannel on success and a crate::lightning::ln::msgs::DecodeError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_ChannelUpdateDecodeErrorZ {
+typedef struct LDKCResult_OpenChannelDecodeErrorZ {
    /**
-    * The contents of this CResult_ChannelUpdateDecodeErrorZ, accessible via either
+    * The contents of this CResult_OpenChannelDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_ChannelUpdateDecodeErrorZPtr contents;
+   union LDKCResult_OpenChannelDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_ChannelUpdateDecodeErrorZ represents a success state.
+    * Whether this CResult_OpenChannelDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_ChannelUpdateDecodeErrorZ;
+} LDKCResult_OpenChannelDecodeErrorZ;
 
 /**
- * The contents of CResult_ErrorMessageDecodeErrorZ
+ * The contents of CResult_RevokeAndACKDecodeErrorZ
  */
-typedef union LDKCResult_ErrorMessageDecodeErrorZPtr {
+typedef union LDKCResult_RevokeAndACKDecodeErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKErrorMessage *result;
+   struct LDKRevokeAndACK *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
    struct LDKDecodeError *err;
-} LDKCResult_ErrorMessageDecodeErrorZPtr;
+} LDKCResult_RevokeAndACKDecodeErrorZPtr;
 
 /**
- * A CResult_ErrorMessageDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::ln::msgs::ErrorMessage on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * A CResult_RevokeAndACKDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::ln::msgs::RevokeAndACK on success and a crate::lightning::ln::msgs::DecodeError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_ErrorMessageDecodeErrorZ {
+typedef struct LDKCResult_RevokeAndACKDecodeErrorZ {
    /**
-    * The contents of this CResult_ErrorMessageDecodeErrorZ, accessible via either
+    * The contents of this CResult_RevokeAndACKDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_ErrorMessageDecodeErrorZPtr contents;
+   union LDKCResult_RevokeAndACKDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_ErrorMessageDecodeErrorZ represents a success state.
+    * Whether this CResult_RevokeAndACKDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_ErrorMessageDecodeErrorZ;
-
-
-
-/**
- * The unsigned part of a node_announcement
- */
-typedef struct MUST_USE_STRUCT LDKUnsignedNodeAnnouncement {
-   /**
-    * A pointer to the opaque Rust object.
-    * Nearly everywhere, inner must be non-null, however in places where
-    * the Rust equivalent takes an Option, it may be set to null to indicate None.
-    */
-   LDKnativeUnsignedNodeAnnouncement *inner;
-   /**
-    * Indicates that this is the only struct which contains the same pointer.
-    * Rust functions which take ownership of an object provided via an argument require
-    * this to be true and invalidate the object pointed to by inner.
-    */
-   bool is_owned;
-} LDKUnsignedNodeAnnouncement;
+} LDKCResult_RevokeAndACKDecodeErrorZ;
 
 /**
- * The contents of CResult_UnsignedNodeAnnouncementDecodeErrorZ
+ * The contents of CResult_ShutdownDecodeErrorZ
  */
-typedef union LDKCResult_UnsignedNodeAnnouncementDecodeErrorZPtr {
+typedef union LDKCResult_ShutdownDecodeErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKUnsignedNodeAnnouncement *result;
+   struct LDKShutdown *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
    struct LDKDecodeError *err;
-} LDKCResult_UnsignedNodeAnnouncementDecodeErrorZPtr;
+} LDKCResult_ShutdownDecodeErrorZPtr;
 
 /**
- * A CResult_UnsignedNodeAnnouncementDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::ln::msgs::UnsignedNodeAnnouncement on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * A CResult_ShutdownDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::ln::msgs::Shutdown on success and a crate::lightning::ln::msgs::DecodeError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ {
+typedef struct LDKCResult_ShutdownDecodeErrorZ {
    /**
-    * The contents of this CResult_UnsignedNodeAnnouncementDecodeErrorZ, accessible via either
+    * The contents of this CResult_ShutdownDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_UnsignedNodeAnnouncementDecodeErrorZPtr contents;
+   union LDKCResult_ShutdownDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_UnsignedNodeAnnouncementDecodeErrorZ represents a success state.
+    * Whether this CResult_ShutdownDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ;
+} LDKCResult_ShutdownDecodeErrorZ;
 
 /**
- * The contents of CResult_NodeAnnouncementDecodeErrorZ
+ * The contents of CResult_UpdateFailHTLCDecodeErrorZ
  */
-typedef union LDKCResult_NodeAnnouncementDecodeErrorZPtr {
+typedef union LDKCResult_UpdateFailHTLCDecodeErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKNodeAnnouncement *result;
+   struct LDKUpdateFailHTLC *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
    struct LDKDecodeError *err;
-} LDKCResult_NodeAnnouncementDecodeErrorZPtr;
+} LDKCResult_UpdateFailHTLCDecodeErrorZPtr;
 
 /**
- * A CResult_NodeAnnouncementDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::ln::msgs::NodeAnnouncement on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * A CResult_UpdateFailHTLCDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::ln::msgs::UpdateFailHTLC on success and a crate::lightning::ln::msgs::DecodeError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_NodeAnnouncementDecodeErrorZ {
+typedef struct LDKCResult_UpdateFailHTLCDecodeErrorZ {
    /**
-    * The contents of this CResult_NodeAnnouncementDecodeErrorZ, accessible via either
+    * The contents of this CResult_UpdateFailHTLCDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_NodeAnnouncementDecodeErrorZPtr contents;
+   union LDKCResult_UpdateFailHTLCDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_NodeAnnouncementDecodeErrorZ represents a success state.
+    * Whether this CResult_UpdateFailHTLCDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_NodeAnnouncementDecodeErrorZ;
+} LDKCResult_UpdateFailHTLCDecodeErrorZ;
 
 /**
- * The contents of CResult_QueryShortChannelIdsDecodeErrorZ
+ * The contents of CResult_UpdateFailMalformedHTLCDecodeErrorZ
  */
-typedef union LDKCResult_QueryShortChannelIdsDecodeErrorZPtr {
+typedef union LDKCResult_UpdateFailMalformedHTLCDecodeErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKQueryShortChannelIds *result;
+   struct LDKUpdateFailMalformedHTLC *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
    struct LDKDecodeError *err;
-} LDKCResult_QueryShortChannelIdsDecodeErrorZPtr;
+} LDKCResult_UpdateFailMalformedHTLCDecodeErrorZPtr;
 
 /**
- * A CResult_QueryShortChannelIdsDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::ln::msgs::QueryShortChannelIds on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * A CResult_UpdateFailMalformedHTLCDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::ln::msgs::UpdateFailMalformedHTLC on success and a crate::lightning::ln::msgs::DecodeError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_QueryShortChannelIdsDecodeErrorZ {
+typedef struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ {
    /**
-    * The contents of this CResult_QueryShortChannelIdsDecodeErrorZ, accessible via either
+    * The contents of this CResult_UpdateFailMalformedHTLCDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_QueryShortChannelIdsDecodeErrorZPtr contents;
+   union LDKCResult_UpdateFailMalformedHTLCDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_QueryShortChannelIdsDecodeErrorZ represents a success state.
+    * Whether this CResult_UpdateFailMalformedHTLCDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_QueryShortChannelIdsDecodeErrorZ;
+} LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ;
 
 
 
 /**
- * A reply_short_channel_ids_end message is sent as a reply to a
- * query_short_channel_ids message. The query recipient makes a best
- * effort to respond based on their local network view which may not be
- * a perfect view of the network.
+ * An update_fee message to be sent or received from a peer
  */
-typedef struct MUST_USE_STRUCT LDKReplyShortChannelIdsEnd {
+typedef struct MUST_USE_STRUCT LDKUpdateFee {
    /**
     * A pointer to the opaque Rust object.
     * Nearly everywhere, inner must be non-null, however in places where
     * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   LDKnativeReplyShortChannelIdsEnd *inner;
+   LDKnativeUpdateFee *inner;
    /**
     * Indicates that this is the only struct which contains the same pointer.
     * Rust functions which take ownership of an object provided via an argument require
     * this to be true and invalidate the object pointed to by inner.
     */
    bool is_owned;
-} LDKReplyShortChannelIdsEnd;
+} LDKUpdateFee;
 
 /**
- * The contents of CResult_ReplyShortChannelIdsEndDecodeErrorZ
+ * The contents of CResult_UpdateFeeDecodeErrorZ
  */
-typedef union LDKCResult_ReplyShortChannelIdsEndDecodeErrorZPtr {
+typedef union LDKCResult_UpdateFeeDecodeErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKReplyShortChannelIdsEnd *result;
+   struct LDKUpdateFee *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
    struct LDKDecodeError *err;
-} LDKCResult_ReplyShortChannelIdsEndDecodeErrorZPtr;
+} LDKCResult_UpdateFeeDecodeErrorZPtr;
 
 /**
- * A CResult_ReplyShortChannelIdsEndDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::ln::msgs::ReplyShortChannelIdsEnd on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * A CResult_UpdateFeeDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::ln::msgs::UpdateFee on success and a crate::lightning::ln::msgs::DecodeError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ {
+typedef struct LDKCResult_UpdateFeeDecodeErrorZ {
    /**
-    * The contents of this CResult_ReplyShortChannelIdsEndDecodeErrorZ, accessible via either
+    * The contents of this CResult_UpdateFeeDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_ReplyShortChannelIdsEndDecodeErrorZPtr contents;
+   union LDKCResult_UpdateFeeDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_ReplyShortChannelIdsEndDecodeErrorZ represents a success state.
+    * Whether this CResult_UpdateFeeDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ;
+} LDKCResult_UpdateFeeDecodeErrorZ;
 
 /**
- * The contents of CResult_QueryChannelRangeDecodeErrorZ
+ * The contents of CResult_UpdateFulfillHTLCDecodeErrorZ
  */
-typedef union LDKCResult_QueryChannelRangeDecodeErrorZPtr {
+typedef union LDKCResult_UpdateFulfillHTLCDecodeErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKQueryChannelRange *result;
+   struct LDKUpdateFulfillHTLC *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
    struct LDKDecodeError *err;
-} LDKCResult_QueryChannelRangeDecodeErrorZPtr;
+} LDKCResult_UpdateFulfillHTLCDecodeErrorZPtr;
 
 /**
- * A CResult_QueryChannelRangeDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::ln::msgs::QueryChannelRange on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * A CResult_UpdateFulfillHTLCDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::ln::msgs::UpdateFulfillHTLC on success and a crate::lightning::ln::msgs::DecodeError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_QueryChannelRangeDecodeErrorZ {
+typedef struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ {
    /**
-    * The contents of this CResult_QueryChannelRangeDecodeErrorZ, accessible via either
+    * The contents of this CResult_UpdateFulfillHTLCDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_QueryChannelRangeDecodeErrorZPtr contents;
+   union LDKCResult_UpdateFulfillHTLCDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_QueryChannelRangeDecodeErrorZ represents a success state.
+    * Whether this CResult_UpdateFulfillHTLCDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_QueryChannelRangeDecodeErrorZ;
+} LDKCResult_UpdateFulfillHTLCDecodeErrorZ;
 
 /**
- * The contents of CResult_ReplyChannelRangeDecodeErrorZ
+ * The contents of CResult_UpdateAddHTLCDecodeErrorZ
  */
-typedef union LDKCResult_ReplyChannelRangeDecodeErrorZPtr {
+typedef union LDKCResult_UpdateAddHTLCDecodeErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKReplyChannelRange *result;
+   struct LDKUpdateAddHTLC *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
    struct LDKDecodeError *err;
-} LDKCResult_ReplyChannelRangeDecodeErrorZPtr;
+} LDKCResult_UpdateAddHTLCDecodeErrorZPtr;
 
 /**
- * A CResult_ReplyChannelRangeDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::ln::msgs::ReplyChannelRange on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * A CResult_UpdateAddHTLCDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::ln::msgs::UpdateAddHTLC on success and a crate::lightning::ln::msgs::DecodeError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_ReplyChannelRangeDecodeErrorZ {
+typedef struct LDKCResult_UpdateAddHTLCDecodeErrorZ {
    /**
-    * The contents of this CResult_ReplyChannelRangeDecodeErrorZ, accessible via either
+    * The contents of this CResult_UpdateAddHTLCDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_ReplyChannelRangeDecodeErrorZPtr contents;
+   union LDKCResult_UpdateAddHTLCDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_ReplyChannelRangeDecodeErrorZ represents a success state.
+    * Whether this CResult_UpdateAddHTLCDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_ReplyChannelRangeDecodeErrorZ;
+} LDKCResult_UpdateAddHTLCDecodeErrorZ;
 
 
 
 /**
- * A gossip_timestamp_filter message is used by a node to request
- * gossip relay for messages in the requested time range when the
- * gossip_queries feature has been negotiated.
+ * A ping message to be sent or received from a peer
  */
-typedef struct MUST_USE_STRUCT LDKGossipTimestampFilter {
+typedef struct MUST_USE_STRUCT LDKPing {
    /**
     * A pointer to the opaque Rust object.
     * Nearly everywhere, inner must be non-null, however in places where
     * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   LDKnativeGossipTimestampFilter *inner;
+   LDKnativePing *inner;
    /**
     * Indicates that this is the only struct which contains the same pointer.
     * Rust functions which take ownership of an object provided via an argument require
     * this to be true and invalidate the object pointed to by inner.
     */
    bool is_owned;
-} LDKGossipTimestampFilter;
+} LDKPing;
 
 /**
- * The contents of CResult_GossipTimestampFilterDecodeErrorZ
+ * The contents of CResult_PingDecodeErrorZ
  */
-typedef union LDKCResult_GossipTimestampFilterDecodeErrorZPtr {
+typedef union LDKCResult_PingDecodeErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKGossipTimestampFilter *result;
+   struct LDKPing *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
    struct LDKDecodeError *err;
-} LDKCResult_GossipTimestampFilterDecodeErrorZPtr;
+} LDKCResult_PingDecodeErrorZPtr;
 
 /**
- * A CResult_GossipTimestampFilterDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::ln::msgs::GossipTimestampFilter on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * A CResult_PingDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::ln::msgs::Ping on success and a crate::lightning::ln::msgs::DecodeError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_GossipTimestampFilterDecodeErrorZ {
+typedef struct LDKCResult_PingDecodeErrorZ {
    /**
-    * The contents of this CResult_GossipTimestampFilterDecodeErrorZ, accessible via either
+    * The contents of this CResult_PingDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_GossipTimestampFilterDecodeErrorZPtr contents;
+   union LDKCResult_PingDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_GossipTimestampFilterDecodeErrorZ represents a success state.
+    * Whether this CResult_PingDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_GossipTimestampFilterDecodeErrorZ;
+} LDKCResult_PingDecodeErrorZ;
+
+
 
 /**
- * The contents of CResult_SpendableOutputDescriptorDecodeErrorZ
+ * A pong message to be sent or received from a peer
  */
-typedef union LDKCResult_SpendableOutputDescriptorDecodeErrorZPtr {
+typedef struct MUST_USE_STRUCT LDKPong {
+   /**
+    * A pointer to the opaque Rust object.
+    * Nearly everywhere, inner must be non-null, however in places where
+    * the Rust equivalent takes an Option, it may be set to null to indicate None.
+    */
+   LDKnativePong *inner;
+   /**
+    * Indicates that this is the only struct which contains the same pointer.
+    * Rust functions which take ownership of an object provided via an argument require
+    * this to be true and invalidate the object pointed to by inner.
+    */
+   bool is_owned;
+} LDKPong;
+
+/**
+ * The contents of CResult_PongDecodeErrorZ
+ */
+typedef union LDKCResult_PongDecodeErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKSpendableOutputDescriptor *result;
+   struct LDKPong *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
    struct LDKDecodeError *err;
-} LDKCResult_SpendableOutputDescriptorDecodeErrorZPtr;
+} LDKCResult_PongDecodeErrorZPtr;
 
 /**
- * A CResult_SpendableOutputDescriptorDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::chain::keysinterface::SpendableOutputDescriptor on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * A CResult_PongDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::ln::msgs::Pong on success and a crate::lightning::ln::msgs::DecodeError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ {
+typedef struct LDKCResult_PongDecodeErrorZ {
    /**
-    * The contents of this CResult_SpendableOutputDescriptorDecodeErrorZ, accessible via either
+    * The contents of this CResult_PongDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_SpendableOutputDescriptorDecodeErrorZPtr contents;
+   union LDKCResult_PongDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_SpendableOutputDescriptorDecodeErrorZ represents a success state.
+    * Whether this CResult_PongDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_SpendableOutputDescriptorDecodeErrorZ;
+} LDKCResult_PongDecodeErrorZ;
 
 /**
- * The contents of CResult_SignDecodeErrorZ
+ * The contents of CResult_UnsignedChannelAnnouncementDecodeErrorZ
  */
-typedef union LDKCResult_SignDecodeErrorZPtr {
+typedef union LDKCResult_UnsignedChannelAnnouncementDecodeErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKSign *result;
+   struct LDKUnsignedChannelAnnouncement *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
    struct LDKDecodeError *err;
-} LDKCResult_SignDecodeErrorZPtr;
+} LDKCResult_UnsignedChannelAnnouncementDecodeErrorZPtr;
 
 /**
- * A CResult_SignDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::chain::keysinterface::Sign on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * A CResult_UnsignedChannelAnnouncementDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::ln::msgs::UnsignedChannelAnnouncement on success and a crate::lightning::ln::msgs::DecodeError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_SignDecodeErrorZ {
+typedef struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ {
    /**
-    * The contents of this CResult_SignDecodeErrorZ, accessible via either
+    * The contents of this CResult_UnsignedChannelAnnouncementDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_SignDecodeErrorZPtr contents;
+   union LDKCResult_UnsignedChannelAnnouncementDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_SignDecodeErrorZ represents a success state.
+    * Whether this CResult_UnsignedChannelAnnouncementDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_SignDecodeErrorZ;
-
-/**
- * A dynamically-allocated array of crate::c_types::derived::CVec_u8Zs of arbitrary size.
- * This corresponds to std::vector in C++
- */
-typedef struct LDKCVec_CVec_u8ZZ {
-   /**
-    * The elements in the array.
-    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
-    */
-   struct LDKCVec_u8Z *data;
-   /**
-    * The number of elements pointed to by `data`.
-    */
-   uintptr_t datalen;
-} LDKCVec_CVec_u8ZZ;
+} LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ;
 
 /**
- * The contents of CResult_CVec_CVec_u8ZZNoneZ
+ * The contents of CResult_ChannelAnnouncementDecodeErrorZ
  */
-typedef union LDKCResult_CVec_CVec_u8ZZNoneZPtr {
+typedef union LDKCResult_ChannelAnnouncementDecodeErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKCVec_CVec_u8ZZ *result;
+   struct LDKChannelAnnouncement *result;
    /**
-    * Note that this value is always NULL, as there are no contents in the Err variant
+    * A pointer to the contents in the error state.
+    * Reading from this pointer when `result_ok` is set is undefined.
     */
-   void *err;
-} LDKCResult_CVec_CVec_u8ZZNoneZPtr;
+   struct LDKDecodeError *err;
+} LDKCResult_ChannelAnnouncementDecodeErrorZPtr;
 
 /**
- * A CResult_CVec_CVec_u8ZZNoneZ represents the result of a fallible operation,
- * containing a crate::c_types::derived::CVec_CVec_u8ZZ on success and a () on failure.
+ * A CResult_ChannelAnnouncementDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::ln::msgs::ChannelAnnouncement on success and a crate::lightning::ln::msgs::DecodeError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_CVec_CVec_u8ZZNoneZ {
+typedef struct LDKCResult_ChannelAnnouncementDecodeErrorZ {
    /**
-    * The contents of this CResult_CVec_CVec_u8ZZNoneZ, accessible via either
+    * The contents of this CResult_ChannelAnnouncementDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_CVec_CVec_u8ZZNoneZPtr contents;
+   union LDKCResult_ChannelAnnouncementDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_CVec_CVec_u8ZZNoneZ represents a success state.
+    * Whether this CResult_ChannelAnnouncementDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_CVec_CVec_u8ZZNoneZ;
+} LDKCResult_ChannelAnnouncementDecodeErrorZ;
 
 
 
 /**
- * A simple implementation of Sign that just keeps the private keys in memory.
- *
- * This implementation performs no policy checks and is insufficient by itself as
- * a secure external signer.
+ * The unsigned part of a channel_update
  */
-typedef struct MUST_USE_STRUCT LDKInMemorySigner {
+typedef struct MUST_USE_STRUCT LDKUnsignedChannelUpdate {
    /**
     * A pointer to the opaque Rust object.
     * Nearly everywhere, inner must be non-null, however in places where
     * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   LDKnativeInMemorySigner *inner;
+   LDKnativeUnsignedChannelUpdate *inner;
    /**
     * Indicates that this is the only struct which contains the same pointer.
     * Rust functions which take ownership of an object provided via an argument require
     * this to be true and invalidate the object pointed to by inner.
     */
    bool is_owned;
-} LDKInMemorySigner;
+} LDKUnsignedChannelUpdate;
 
 /**
- * The contents of CResult_InMemorySignerDecodeErrorZ
+ * The contents of CResult_UnsignedChannelUpdateDecodeErrorZ
  */
-typedef union LDKCResult_InMemorySignerDecodeErrorZPtr {
+typedef union LDKCResult_UnsignedChannelUpdateDecodeErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKInMemorySigner *result;
+   struct LDKUnsignedChannelUpdate *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
    struct LDKDecodeError *err;
-} LDKCResult_InMemorySignerDecodeErrorZPtr;
+} LDKCResult_UnsignedChannelUpdateDecodeErrorZPtr;
 
 /**
- * A CResult_InMemorySignerDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::chain::keysinterface::InMemorySigner on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * A CResult_UnsignedChannelUpdateDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::ln::msgs::UnsignedChannelUpdate on success and a crate::lightning::ln::msgs::DecodeError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_InMemorySignerDecodeErrorZ {
+typedef struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ {
    /**
-    * The contents of this CResult_InMemorySignerDecodeErrorZ, accessible via either
+    * The contents of this CResult_UnsignedChannelUpdateDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_InMemorySignerDecodeErrorZPtr contents;
+   union LDKCResult_UnsignedChannelUpdateDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_InMemorySignerDecodeErrorZ represents a success state.
+    * Whether this CResult_UnsignedChannelUpdateDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_InMemorySignerDecodeErrorZ;
-
-/**
- * A dynamically-allocated array of crate::c_types::TxOuts of arbitrary size.
- * This corresponds to std::vector in C++
- */
-typedef struct LDKCVec_TxOutZ {
-   /**
-    * The elements in the array.
-    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
-    */
-   struct LDKTxOut *data;
-   /**
-    * The number of elements pointed to by `data`.
-    */
-   uintptr_t datalen;
-} LDKCVec_TxOutZ;
+} LDKCResult_UnsignedChannelUpdateDecodeErrorZ;
 
 /**
- * The contents of CResult_TransactionNoneZ
+ * The contents of CResult_ChannelUpdateDecodeErrorZ
  */
-typedef union LDKCResult_TransactionNoneZPtr {
+typedef union LDKCResult_ChannelUpdateDecodeErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKTransaction *result;
+   struct LDKChannelUpdate *result;
    /**
-    * Note that this value is always NULL, as there are no contents in the Err variant
+    * A pointer to the contents in the error state.
+    * Reading from this pointer when `result_ok` is set is undefined.
     */
-   void *err;
-} LDKCResult_TransactionNoneZPtr;
+   struct LDKDecodeError *err;
+} LDKCResult_ChannelUpdateDecodeErrorZPtr;
 
 /**
- * A CResult_TransactionNoneZ represents the result of a fallible operation,
- * containing a crate::c_types::Transaction on success and a () on failure.
+ * A CResult_ChannelUpdateDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::ln::msgs::ChannelUpdate on success and a crate::lightning::ln::msgs::DecodeError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_TransactionNoneZ {
+typedef struct LDKCResult_ChannelUpdateDecodeErrorZ {
    /**
-    * The contents of this CResult_TransactionNoneZ, accessible via either
+    * The contents of this CResult_ChannelUpdateDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_TransactionNoneZPtr contents;
+   union LDKCResult_ChannelUpdateDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_TransactionNoneZ represents a success state.
+    * Whether this CResult_ChannelUpdateDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_TransactionNoneZ;
+} LDKCResult_ChannelUpdateDecodeErrorZ;
 
 /**
- * The contents of CResult_NoneErrorZ
+ * The contents of CResult_ErrorMessageDecodeErrorZ
  */
-typedef union LDKCResult_NoneErrorZPtr {
+typedef union LDKCResult_ErrorMessageDecodeErrorZPtr {
    /**
-    * Note that this value is always NULL, as there are no contents in the OK variant
+    * A pointer to the contents in the success state.
+    * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   void *result;
+   struct LDKErrorMessage *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
-   enum LDKIOError *err;
-} LDKCResult_NoneErrorZPtr;
+   struct LDKDecodeError *err;
+} LDKCResult_ErrorMessageDecodeErrorZPtr;
 
 /**
- * A CResult_NoneErrorZ represents the result of a fallible operation,
- * containing a () on success and a crate::c_types::IOError on failure.
+ * A CResult_ErrorMessageDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::ln::msgs::ErrorMessage on success and a crate::lightning::ln::msgs::DecodeError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_NoneErrorZ {
+typedef struct LDKCResult_ErrorMessageDecodeErrorZ {
    /**
-    * The contents of this CResult_NoneErrorZ, accessible via either
+    * The contents of this CResult_ErrorMessageDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_NoneErrorZPtr contents;
+   union LDKCResult_ErrorMessageDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_NoneErrorZ represents a success state.
+    * Whether this CResult_ErrorMessageDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_NoneErrorZ;
+} LDKCResult_ErrorMessageDecodeErrorZ;
+
+
 
 /**
- * A dynamically-allocated array of crate::c_types::derived::C2Tuple_BlockHashChannelMonitorZs of arbitrary size.
- * This corresponds to std::vector in C++
+ * The unsigned part of a node_announcement
  */
-typedef struct LDKCVec_C2Tuple_BlockHashChannelMonitorZZ {
+typedef struct MUST_USE_STRUCT LDKUnsignedNodeAnnouncement {
    /**
-    * The elements in the array.
-    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+    * A pointer to the opaque Rust object.
+    * Nearly everywhere, inner must be non-null, however in places where
+    * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   struct LDKC2Tuple_BlockHashChannelMonitorZ *data;
+   LDKnativeUnsignedNodeAnnouncement *inner;
    /**
-    * The number of elements pointed to by `data`.
+    * Indicates that this is the only struct which contains the same pointer.
+    * Rust functions which take ownership of an object provided via an argument require
+    * this to be true and invalidate the object pointed to by inner.
     */
-   uintptr_t datalen;
-} LDKCVec_C2Tuple_BlockHashChannelMonitorZZ;
+   bool is_owned;
+} LDKUnsignedNodeAnnouncement;
 
 /**
- * The contents of CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ
+ * The contents of CResult_UnsignedNodeAnnouncementDecodeErrorZ
  */
-typedef union LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZPtr {
+typedef union LDKCResult_UnsignedNodeAnnouncementDecodeErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKCVec_C2Tuple_BlockHashChannelMonitorZZ *result;
+   struct LDKUnsignedNodeAnnouncement *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
-   enum LDKIOError *err;
-} LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZPtr;
+   struct LDKDecodeError *err;
+} LDKCResult_UnsignedNodeAnnouncementDecodeErrorZPtr;
 
 /**
- * A CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ represents the result of a fallible operation,
- * containing a crate::c_types::derived::CVec_C2Tuple_BlockHashChannelMonitorZZ on success and a crate::c_types::IOError on failure.
+ * A CResult_UnsignedNodeAnnouncementDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::ln::msgs::UnsignedNodeAnnouncement on success and a crate::lightning::ln::msgs::DecodeError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ {
+typedef struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ {
    /**
-    * The contents of this CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ, accessible via either
+    * The contents of this CResult_UnsignedNodeAnnouncementDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZPtr contents;
+   union LDKCResult_UnsignedNodeAnnouncementDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ represents a success state.
+    * Whether this CResult_UnsignedNodeAnnouncementDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ;
+} LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ;
 
 /**
- * A Rust str object, ie a reference to a UTF8-valid string.
- * This is *not* null-terminated so cannot be used directly as a C string!
+ * The contents of CResult_NodeAnnouncementDecodeErrorZ
  */
-typedef struct LDKStr {
+typedef union LDKCResult_NodeAnnouncementDecodeErrorZPtr {
    /**
-    * A pointer to the string's bytes, in UTF8 encoding
+    * A pointer to the contents in the success state.
+    * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   const uint8_t *chars;
+   struct LDKNodeAnnouncement *result;
    /**
-    * The number of bytes (not characters!) pointed to by `chars`
+    * A pointer to the contents in the error state.
+    * Reading from this pointer when `result_ok` is set is undefined.
     */
-   uintptr_t len;
-} LDKStr;
+   struct LDKDecodeError *err;
+} LDKCResult_NodeAnnouncementDecodeErrorZPtr;
 
 /**
- * Indicates an error on the client's part (usually some variant of attempting to use too-low or
- * too-high values)
+ * A CResult_NodeAnnouncementDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::ln::msgs::NodeAnnouncement on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef enum LDKAPIError_Tag {
+typedef struct LDKCResult_NodeAnnouncementDecodeErrorZ {
    /**
-    * Indicates the API was wholly misused (see err for more). Cases where these can be returned
-    * are documented, but generally indicates some precondition of a function was violated.
+    * The contents of this CResult_NodeAnnouncementDecodeErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   LDKAPIError_APIMisuseError,
+   union LDKCResult_NodeAnnouncementDecodeErrorZPtr contents;
    /**
-    * Due to a high feerate, we were unable to complete the request.
-    * For example, this may be returned if the feerate implies we cannot open a channel at the
-    * requested value, but opening a larger channel would succeed.
+    * Whether this CResult_NodeAnnouncementDecodeErrorZ represents a success state.
     */
-   LDKAPIError_FeeRateTooHigh,
+   bool result_ok;
+} LDKCResult_NodeAnnouncementDecodeErrorZ;
+
+/**
+ * The contents of CResult_QueryShortChannelIdsDecodeErrorZ
+ */
+typedef union LDKCResult_QueryShortChannelIdsDecodeErrorZPtr {
    /**
-    * A malformed Route was provided (eg overflowed value, node id mismatch, overly-looped route,
-    * too-many-hops, etc).
+    * A pointer to the contents in the success state.
+    * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   LDKAPIError_RouteError,
+   struct LDKQueryShortChannelIds *result;
    /**
-    * We were unable to complete the request as the Channel required to do so is unable to
-    * complete the request (or was not found). This can take many forms, including disconnected
-    * peer, channel at capacity, channel shutting down, etc.
+    * A pointer to the contents in the error state.
+    * Reading from this pointer when `result_ok` is set is undefined.
     */
-   LDKAPIError_ChannelUnavailable,
+   struct LDKDecodeError *err;
+} LDKCResult_QueryShortChannelIdsDecodeErrorZPtr;
+
+/**
+ * A CResult_QueryShortChannelIdsDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::ln::msgs::QueryShortChannelIds on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * `result_ok` indicates the overall state, and the contents are provided via `contents`.
+ */
+typedef struct LDKCResult_QueryShortChannelIdsDecodeErrorZ {
    /**
-    * An attempt to call watch/update_channel returned an Err (ie you did this!), causing the
-    * attempted action to fail.
+    * The contents of this CResult_QueryShortChannelIdsDecodeErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   LDKAPIError_MonitorUpdateFailed,
+   union LDKCResult_QueryShortChannelIdsDecodeErrorZPtr contents;
    /**
-    * Must be last for serialization purposes
+    * Whether this CResult_QueryShortChannelIdsDecodeErrorZ represents a success state.
     */
-   LDKAPIError_Sentinel,
-} LDKAPIError_Tag;
+   bool result_ok;
+} LDKCResult_QueryShortChannelIdsDecodeErrorZ;
 
-typedef struct LDKAPIError_LDKAPIMisuseError_Body {
-   /**
-    * A human-readable error message
-    */
-   struct LDKCVec_u8Z err;
-} LDKAPIError_LDKAPIMisuseError_Body;
 
-typedef struct LDKAPIError_LDKFeeRateTooHigh_Body {
-   /**
-    * A human-readable error message
-    */
-   struct LDKCVec_u8Z err;
-   /**
-    * The feerate which was too high.
-    */
-   uint32_t feerate;
-} LDKAPIError_LDKFeeRateTooHigh_Body;
 
-typedef struct LDKAPIError_LDKRouteError_Body {
+/**
+ * A reply_short_channel_ids_end message is sent as a reply to a
+ * query_short_channel_ids message. The query recipient makes a best
+ * effort to respond based on their local network view which may not be
+ * a perfect view of the network.
+ */
+typedef struct MUST_USE_STRUCT LDKReplyShortChannelIdsEnd {
    /**
-    * A human-readable error message
+    * A pointer to the opaque Rust object.
+    * Nearly everywhere, inner must be non-null, however in places where
+    * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   struct LDKStr err;
-} LDKAPIError_LDKRouteError_Body;
-
-typedef struct LDKAPIError_LDKChannelUnavailable_Body {
+   LDKnativeReplyShortChannelIdsEnd *inner;
    /**
-    * A human-readable error message
+    * Indicates that this is the only struct which contains the same pointer.
+    * Rust functions which take ownership of an object provided via an argument require
+    * this to be true and invalidate the object pointed to by inner.
     */
-   struct LDKCVec_u8Z err;
-} LDKAPIError_LDKChannelUnavailable_Body;
-
-typedef struct MUST_USE_STRUCT LDKAPIError {
-   LDKAPIError_Tag tag;
-   union {
-      LDKAPIError_LDKAPIMisuseError_Body api_misuse_error;
-      LDKAPIError_LDKFeeRateTooHigh_Body fee_rate_too_high;
-      LDKAPIError_LDKRouteError_Body route_error;
-      LDKAPIError_LDKChannelUnavailable_Body channel_unavailable;
-   };
-} LDKAPIError;
+   bool is_owned;
+} LDKReplyShortChannelIdsEnd;
 
 /**
- * The contents of CResult_NoneAPIErrorZ
+ * The contents of CResult_ReplyShortChannelIdsEndDecodeErrorZ
  */
-typedef union LDKCResult_NoneAPIErrorZPtr {
+typedef union LDKCResult_ReplyShortChannelIdsEndDecodeErrorZPtr {
    /**
-    * Note that this value is always NULL, as there are no contents in the OK variant
+    * A pointer to the contents in the success state.
+    * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   void *result;
+   struct LDKReplyShortChannelIdsEnd *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
-   struct LDKAPIError *err;
-} LDKCResult_NoneAPIErrorZPtr;
+   struct LDKDecodeError *err;
+} LDKCResult_ReplyShortChannelIdsEndDecodeErrorZPtr;
 
 /**
- * A CResult_NoneAPIErrorZ represents the result of a fallible operation,
- * containing a () on success and a crate::lightning::util::errors::APIError on failure.
+ * A CResult_ReplyShortChannelIdsEndDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::ln::msgs::ReplyShortChannelIdsEnd on success and a crate::lightning::ln::msgs::DecodeError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_NoneAPIErrorZ {
+typedef struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ {
    /**
-    * The contents of this CResult_NoneAPIErrorZ, accessible via either
+    * The contents of this CResult_ReplyShortChannelIdsEndDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_NoneAPIErrorZPtr contents;
+   union LDKCResult_ReplyShortChannelIdsEndDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_NoneAPIErrorZ represents a success state.
+    * Whether this CResult_ReplyShortChannelIdsEndDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_NoneAPIErrorZ;
+} LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ;
 
 /**
- * A dynamically-allocated array of crate::c_types::derived::CResult_NoneAPIErrorZs of arbitrary size.
- * This corresponds to std::vector in C++
+ * The contents of CResult_QueryChannelRangeDecodeErrorZ
  */
-typedef struct LDKCVec_CResult_NoneAPIErrorZZ {
+typedef union LDKCResult_QueryChannelRangeDecodeErrorZPtr {
    /**
-    * The elements in the array.
-    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+    * A pointer to the contents in the success state.
+    * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKCResult_NoneAPIErrorZ *data;
+   struct LDKQueryChannelRange *result;
    /**
-    * The number of elements pointed to by `data`.
+    * A pointer to the contents in the error state.
+    * Reading from this pointer when `result_ok` is set is undefined.
     */
-   uintptr_t datalen;
-} LDKCVec_CResult_NoneAPIErrorZZ;
+   struct LDKDecodeError *err;
+} LDKCResult_QueryChannelRangeDecodeErrorZPtr;
 
 /**
- * A dynamically-allocated array of crate::lightning::util::errors::APIErrors of arbitrary size.
- * This corresponds to std::vector in C++
+ * A CResult_QueryChannelRangeDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::ln::msgs::QueryChannelRange on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCVec_APIErrorZ {
+typedef struct LDKCResult_QueryChannelRangeDecodeErrorZ {
    /**
-    * The elements in the array.
-    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+    * The contents of this CResult_QueryChannelRangeDecodeErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   struct LDKAPIError *data;
+   union LDKCResult_QueryChannelRangeDecodeErrorZPtr contents;
    /**
-    * The number of elements pointed to by `data`.
+    * Whether this CResult_QueryChannelRangeDecodeErrorZ represents a success state.
     */
-   uintptr_t datalen;
-} LDKCVec_APIErrorZ;
+   bool result_ok;
+} LDKCResult_QueryChannelRangeDecodeErrorZ;
 
 /**
- * If a payment fails to send, it can be in one of several states. This enum is returned as the
- * Err() type describing which state the payment is in, see the description of individual enum
- * states for more.
+ * The contents of CResult_ReplyChannelRangeDecodeErrorZ
  */
-typedef enum LDKPaymentSendFailure_Tag {
+typedef union LDKCResult_ReplyChannelRangeDecodeErrorZPtr {
    /**
-    * A parameter which was passed to send_payment was invalid, preventing us from attempting to
-    * send the payment at all. No channel state has been changed or messages sent to peers, and
-    * once you've changed the parameter at error, you can freely retry the payment in full.
+    * A pointer to the contents in the success state.
+    * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   LDKPaymentSendFailure_ParameterError,
+   struct LDKReplyChannelRange *result;
    /**
-    * A parameter in a single path which was passed to send_payment was invalid, preventing us
-    * from attempting to send the payment at all. No channel state has been changed or messages
-    * sent to peers, and once you've changed the parameter at error, you can freely retry the
-    * payment in full.
-    *
-    * The results here are ordered the same as the paths in the route object which was passed to
-    * send_payment.
+    * A pointer to the contents in the error state.
+    * Reading from this pointer when `result_ok` is set is undefined.
     */
-   LDKPaymentSendFailure_PathParameterError,
+   struct LDKDecodeError *err;
+} LDKCResult_ReplyChannelRangeDecodeErrorZPtr;
+
+/**
+ * A CResult_ReplyChannelRangeDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::ln::msgs::ReplyChannelRange on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * `result_ok` indicates the overall state, and the contents are provided via `contents`.
+ */
+typedef struct LDKCResult_ReplyChannelRangeDecodeErrorZ {
    /**
-    * All paths which were attempted failed to send, with no channel state change taking place.
-    * You can freely retry the payment in full (though you probably want to do so over different
-    * paths than the ones selected).
+    * The contents of this CResult_ReplyChannelRangeDecodeErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   LDKPaymentSendFailure_AllFailedRetrySafe,
+   union LDKCResult_ReplyChannelRangeDecodeErrorZPtr contents;
    /**
-    * Some paths which were attempted failed to send, though possibly not all. At least some
-    * paths have irrevocably committed to the HTLC and retrying the payment in full would result
-    * in over-/re-payment.
-    *
-    * The results here are ordered the same as the paths in the route object which was passed to
-    * send_payment, and any Errs which are not APIError::MonitorUpdateFailed can be safely
-    * retried (though there is currently no API with which to do so).
-    *
-    * Any entries which contain Err(APIError::MonitorUpdateFailed) or Ok(()) MUST NOT be retried
-    * as they will result in over-/re-payment. These HTLCs all either successfully sent (in the
-    * case of Ok(())) or will send once channel_monitor_updated is called on the next-hop channel
-    * with the latest update_id.
+    * Whether this CResult_ReplyChannelRangeDecodeErrorZ represents a success state.
     */
-   LDKPaymentSendFailure_PartialFailure,
+   bool result_ok;
+} LDKCResult_ReplyChannelRangeDecodeErrorZ;
+
+
+
+/**
+ * A gossip_timestamp_filter message is used by a node to request
+ * gossip relay for messages in the requested time range when the
+ * gossip_queries feature has been negotiated.
+ */
+typedef struct MUST_USE_STRUCT LDKGossipTimestampFilter {
    /**
-    * Must be last for serialization purposes
+    * A pointer to the opaque Rust object.
+    * Nearly everywhere, inner must be non-null, however in places where
+    * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   LDKPaymentSendFailure_Sentinel,
-} LDKPaymentSendFailure_Tag;
-
-typedef struct MUST_USE_STRUCT LDKPaymentSendFailure {
-   LDKPaymentSendFailure_Tag tag;
-   union {
-      struct {
-         struct LDKAPIError parameter_error;
-      };
-      struct {
-         struct LDKCVec_CResult_NoneAPIErrorZZ path_parameter_error;
-      };
-      struct {
-         struct LDKCVec_APIErrorZ all_failed_retry_safe;
-      };
-      struct {
-         struct LDKCVec_CResult_NoneAPIErrorZZ partial_failure;
-      };
-   };
-} LDKPaymentSendFailure;
+   LDKnativeGossipTimestampFilter *inner;
+   /**
+    * Indicates that this is the only struct which contains the same pointer.
+    * Rust functions which take ownership of an object provided via an argument require
+    * this to be true and invalidate the object pointed to by inner.
+    */
+   bool is_owned;
+} LDKGossipTimestampFilter;
 
 /**
- * The contents of CResult_NonePaymentSendFailureZ
+ * The contents of CResult_GossipTimestampFilterDecodeErrorZ
  */
-typedef union LDKCResult_NonePaymentSendFailureZPtr {
+typedef union LDKCResult_GossipTimestampFilterDecodeErrorZPtr {
    /**
-    * Note that this value is always NULL, as there are no contents in the OK variant
+    * A pointer to the contents in the success state.
+    * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   void *result;
+   struct LDKGossipTimestampFilter *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
-   struct LDKPaymentSendFailure *err;
-} LDKCResult_NonePaymentSendFailureZPtr;
+   struct LDKDecodeError *err;
+} LDKCResult_GossipTimestampFilterDecodeErrorZPtr;
 
 /**
- * A CResult_NonePaymentSendFailureZ represents the result of a fallible operation,
- * containing a () on success and a crate::lightning::ln::channelmanager::PaymentSendFailure on failure.
+ * A CResult_GossipTimestampFilterDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::ln::msgs::GossipTimestampFilter on success and a crate::lightning::ln::msgs::DecodeError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_NonePaymentSendFailureZ {
+typedef struct LDKCResult_GossipTimestampFilterDecodeErrorZ {
    /**
-    * The contents of this CResult_NonePaymentSendFailureZ, accessible via either
+    * The contents of this CResult_GossipTimestampFilterDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_NonePaymentSendFailureZPtr contents;
+   union LDKCResult_GossipTimestampFilterDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_NonePaymentSendFailureZ represents a success state.
+    * Whether this CResult_GossipTimestampFilterDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_NonePaymentSendFailureZ;
+} LDKCResult_GossipTimestampFilterDecodeErrorZ;
 
 /**
- * A dynamically-allocated array of crate::lightning::chain::channelmonitor::ChannelMonitors of arbitrary size.
- * This corresponds to std::vector in C++
+ * The contents of CResult_SpendableOutputDescriptorDecodeErrorZ
  */
-typedef struct LDKCVec_ChannelMonitorZ {
+typedef union LDKCResult_SpendableOutputDescriptorDecodeErrorZPtr {
    /**
-    * The elements in the array.
-    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+    * A pointer to the contents in the success state.
+    * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKChannelMonitor *data;
+   struct LDKSpendableOutputDescriptor *result;
    /**
-    * The number of elements pointed to by `data`.
+    * A pointer to the contents in the error state.
+    * Reading from this pointer when `result_ok` is set is undefined.
     */
-   uintptr_t datalen;
-} LDKCVec_ChannelMonitorZ;
+   struct LDKDecodeError *err;
+} LDKCResult_SpendableOutputDescriptorDecodeErrorZPtr;
 
 /**
- * The `Watch` trait defines behavior for watching on-chain activity pertaining to channels as
- * blocks are connected and disconnected.
- *
- * Each channel is associated with a [`ChannelMonitor`]. Implementations of this trait are
- * responsible for maintaining a set of monitors such that they can be updated accordingly as
- * channel state changes and HTLCs are resolved. See method documentation for specific
- * requirements.
- *
- * Implementations **must** ensure that updates are successfully applied and persisted upon method
- * completion. If an update fails with a [`PermanentFailure`], then it must immediately shut down
- * without taking any further action such as persisting the current state.
- *
- * If an implementation maintains multiple instances of a channel's monitor (e.g., by storing
- * backup copies), then it must ensure that updates are applied across all instances. Otherwise, it
- * could result in a revoked transaction being broadcast, allowing the counterparty to claim all
- * funds in the channel. See [`ChannelMonitorUpdateErr`] for more details about how to handle
- * multiple instances.
- *
- * [`ChannelMonitor`]: channelmonitor::ChannelMonitor
- * [`ChannelMonitorUpdateErr`]: channelmonitor::ChannelMonitorUpdateErr
- * [`PermanentFailure`]: channelmonitor::ChannelMonitorUpdateErr::PermanentFailure
+ * A CResult_SpendableOutputDescriptorDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::chain::keysinterface::SpendableOutputDescriptor on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKWatch {
-   /**
-    * An opaque pointer which is passed to your function implementations as an argument.
-    * This has no meaning in the LDK, and can be NULL or any other value.
-    */
-   void *this_arg;
+typedef struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ {
    /**
-    * Watches a channel identified by `funding_txo` using `monitor`.
-    *
-    * Implementations are responsible for watching the chain for the funding transaction along
-    * with any spends of outputs returned by [`get_outputs_to_watch`]. In practice, this means
-    * calling [`block_connected`] and [`block_disconnected`] on the monitor.
-    *
-    * [`get_outputs_to_watch`]: channelmonitor::ChannelMonitor::get_outputs_to_watch
-    * [`block_connected`]: channelmonitor::ChannelMonitor::block_connected
-    * [`block_disconnected`]: channelmonitor::ChannelMonitor::block_disconnected
+    * The contents of this CResult_SpendableOutputDescriptorDecodeErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   struct LDKCResult_NoneChannelMonitorUpdateErrZ (*watch_channel)(const void *this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor);
+   union LDKCResult_SpendableOutputDescriptorDecodeErrorZPtr contents;
    /**
-    * Updates a channel identified by `funding_txo` by applying `update` to its monitor.
-    *
-    * Implementations must call [`update_monitor`] with the given update. See
-    * [`ChannelMonitorUpdateErr`] for invariants around returning an error.
-    *
-    * [`update_monitor`]: channelmonitor::ChannelMonitor::update_monitor
-    * [`ChannelMonitorUpdateErr`]: channelmonitor::ChannelMonitorUpdateErr
+    * Whether this CResult_SpendableOutputDescriptorDecodeErrorZ represents a success state.
     */
-   struct LDKCResult_NoneChannelMonitorUpdateErrZ (*update_channel)(const void *this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitorUpdate update);
+   bool result_ok;
+} LDKCResult_SpendableOutputDescriptorDecodeErrorZ;
+
+/**
+ * The contents of CResult_SignDecodeErrorZ
+ */
+typedef union LDKCResult_SignDecodeErrorZPtr {
    /**
-    * Returns any monitor events since the last call. Subsequent calls must only return new
-    * events.
+    * A pointer to the contents in the success state.
+    * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKCVec_MonitorEventZ (*release_pending_monitor_events)(const void *this_arg);
+   struct LDKSign *result;
    /**
-    * Frees any resources associated with this object given its this_arg pointer.
-    * Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
+    * A pointer to the contents in the error state.
+    * Reading from this pointer when `result_ok` is set is undefined.
     */
-   void (*free)(void *this_arg);
-} LDKWatch;
+   struct LDKDecodeError *err;
+} LDKCResult_SignDecodeErrorZPtr;
 
 /**
- * An interface to send a transaction to the Bitcoin network.
+ * A CResult_SignDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::chain::keysinterface::Sign on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKBroadcasterInterface {
-   /**
-    * An opaque pointer which is passed to your function implementations as an argument.
-    * This has no meaning in the LDK, and can be NULL or any other value.
-    */
-   void *this_arg;
+typedef struct LDKCResult_SignDecodeErrorZ {
    /**
-    * Sends a transaction out to (hopefully) be mined.
+    * The contents of this CResult_SignDecodeErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   void (*broadcast_transaction)(const void *this_arg, struct LDKTransaction tx);
+   union LDKCResult_SignDecodeErrorZPtr contents;
    /**
-    * Frees any resources associated with this object given its this_arg pointer.
-    * Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
+    * Whether this CResult_SignDecodeErrorZ represents a success state.
     */
-   void (*free)(void *this_arg);
-} LDKBroadcasterInterface;
+   bool result_ok;
+} LDKCResult_SignDecodeErrorZ;
 
 /**
- * A "slice" referencing some byte array. This is simply a length-tagged pointer which does not
- * own the memory pointed to by data.
+ * A dynamically-allocated array of crate::c_types::derived::CVec_u8Zs of arbitrary size.
+ * This corresponds to std::vector in C++
  */
-typedef struct LDKu8slice {
+typedef struct LDKCVec_CVec_u8ZZ {
    /**
-    * A pointer to the byte buffer
+    * The elements in the array.
+    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
     */
-   const uint8_t *data;
+   struct LDKCVec_u8Z *data;
    /**
-    * The number of bytes pointed to by `data`.
+    * The number of elements pointed to by `data`.
     */
    uintptr_t datalen;
-} LDKu8slice;
+} LDKCVec_CVec_u8ZZ;
 
 /**
- * A trait to describe an object which can get user secrets and key material.
+ * The contents of CResult_CVec_CVec_u8ZZNoneZ
  */
-typedef struct LDKKeysInterface {
+typedef union LDKCResult_CVec_CVec_u8ZZNoneZPtr {
    /**
-    * An opaque pointer which is passed to your function implementations as an argument.
-    * This has no meaning in the LDK, and can be NULL or any other value.
+    * A pointer to the contents in the success state.
+    * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   void *this_arg;
+   struct LDKCVec_CVec_u8ZZ *result;
    /**
-    * Get node secret key (aka node_id or network_key).
-    *
-    * This method must return the same value each time it is called.
-    */
-   struct LDKSecretKey (*get_node_secret)(const void *this_arg);
-   /**
-    * Get a script pubkey which we send funds to when claiming on-chain contestable outputs.
-    *
-    * This method should return a different value each time it is called, to avoid linking
-    * on-chain funds across channels as controlled to the same user.
-    */
-   struct LDKCVec_u8Z (*get_destination_script)(const void *this_arg);
-   /**
-    * Get a public key which we will send funds to (in the form of a P2WPKH output) when closing
-    * a channel.
-    *
-    * This method should return a different value each time it is called, to avoid linking
-    * on-chain funds across channels as controlled to the same user.
-    */
-   struct LDKPublicKey (*get_shutdown_pubkey)(const void *this_arg);
-   /**
-    * Get a new set of Sign for per-channel secrets. These MUST be unique even if you
-    * restarted with some stale data!
-    *
-    * This method must return a different value each time it is called.
-    */
-   struct LDKSign (*get_channel_signer)(const void *this_arg, bool inbound, uint64_t channel_value_satoshis);
-   /**
-    * Gets a unique, cryptographically-secure, random 32 byte value. This is used for encrypting
-    * onion packets and for temporary channel IDs. There is no requirement that these be
-    * persisted anywhere, though they must be unique across restarts.
-    *
-    * This method must return a different value each time it is called.
-    */
-   struct LDKThirtyTwoBytes (*get_secure_random_bytes)(const void *this_arg);
-   /**
-    * Reads a `Signer` for this `KeysInterface` from the given input stream.
-    * This is only called during deserialization of other objects which contain
-    * `Sign`-implementing objects (ie `ChannelMonitor`s and `ChannelManager`s).
-    * The bytes are exactly those which `<Self::Signer as Writeable>::write()` writes, and
-    * contain no versioning scheme. You may wish to include your own version prefix and ensure
-    * you've read all of the provided bytes to ensure no corruption occurred.
-    */
-   struct LDKCResult_SignDecodeErrorZ (*read_chan_signer)(const void *this_arg, struct LDKu8slice reader);
-   /**
-    * Frees any resources associated with this object given its this_arg pointer.
-    * Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
-    */
-   void (*free)(void *this_arg);
-} LDKKeysInterface;
-
-/**
- * A trait which should be implemented to provide feerate information on a number of time
- * horizons.
- *
- * Note that all of the functions implemented here *must* be reentrant-safe (obviously - they're
- * called from inside the library in response to chain events, P2P events, or timer events).
- */
-typedef struct LDKFeeEstimator {
-   /**
-    * An opaque pointer which is passed to your function implementations as an argument.
-    * This has no meaning in the LDK, and can be NULL or any other value.
-    */
-   void *this_arg;
-   /**
-    * Gets estimated satoshis of fee required per 1000 Weight-Units.
-    *
-    * Must be no smaller than 253 (ie 1 satoshi-per-byte rounded up to ensure later round-downs
-    * don't put us below 1 satoshi-per-byte).
-    *
-    * This translates to:
-    *  * satoshis-per-byte * 250
-    *  * ceil(satoshis-per-kbyte / 4)
-    */
-   uint32_t (*get_est_sat_per_1000_weight)(const void *this_arg, enum LDKConfirmationTarget confirmation_target);
-   /**
-    * Frees any resources associated with this object given its this_arg pointer.
-    * Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
+    * Note that this value is always NULL, as there are no contents in the Err variant
     */
-   void (*free)(void *this_arg);
-} LDKFeeEstimator;
+   void *err;
+} LDKCResult_CVec_CVec_u8ZZNoneZPtr;
 
 /**
- * A trait encapsulating the operations required of a logger
+ * A CResult_CVec_CVec_u8ZZNoneZ represents the result of a fallible operation,
+ * containing a crate::c_types::derived::CVec_CVec_u8ZZ on success and a () on failure.
+ * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKLogger {
-   /**
-    * An opaque pointer which is passed to your function implementations as an argument.
-    * This has no meaning in the LDK, and can be NULL or any other value.
-    */
-   void *this_arg;
+typedef struct LDKCResult_CVec_CVec_u8ZZNoneZ {
    /**
-    * Logs the `Record`
+    * The contents of this CResult_CVec_CVec_u8ZZNoneZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   void (*log)(const void *this_arg, const char *record);
+   union LDKCResult_CVec_CVec_u8ZZNoneZPtr contents;
    /**
-    * Frees any resources associated with this object given its this_arg pointer.
-    * Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
+    * Whether this CResult_CVec_CVec_u8ZZNoneZ represents a success state.
     */
-   void (*free)(void *this_arg);
-} LDKLogger;
+   bool result_ok;
+} LDKCResult_CVec_CVec_u8ZZNoneZ;
 
 
 
 /**
- * Manager which keeps track of a number of channels and sends messages to the appropriate
- * channel, also tracking HTLC preimages and forwarding onion packets appropriately.
- *
- * Implements ChannelMessageHandler, handling the multi-channel parts and passing things through
- * to individual Channels.
- *
- * Implements Writeable to write out all channel state to disk. Implies peer_disconnected() for
- * all peers during write/read (though does not modify this instance, only the instance being
- * serialized). This will result in any channels which have not yet exchanged funding_created (ie
- * called funding_transaction_generated for outbound channels).
- *
- * Note that you can be a bit lazier about writing out ChannelManager than you can be with
- * ChannelMonitors. With ChannelMonitors you MUST write each monitor update out to disk before
- * returning from chain::Watch::watch_/update_channel, with ChannelManagers, writing updates
- * happens out-of-band (and will prevent any other ChannelManager operations from occurring during
- * the serialization process). If the deserialized version is out-of-date compared to the
- * ChannelMonitors passed by reference to read(), those channels will be force-closed based on the
- * ChannelMonitor state and no funds will be lost (mod on-chain transaction fees).
- *
- * Note that the deserializer is only implemented for (BlockHash, ChannelManager), which
- * tells you the last block hash which was block_connect()ed. You MUST rescan any blocks along
- * the \"reorg path\" (ie call block_disconnected() until you get to a common block and then call
- * block_connected() to step towards your best block) upon deserialization before using the
- * object!
- *
- * Note that ChannelManager is responsible for tracking liveness of its channels and generating
- * ChannelUpdate messages informing peers that the channel is temporarily disabled. To avoid
- * spam due to quick disconnection/reconnection, updates are not sent until the channel has been
- * offline for a full minute. In order to track this, you must call
- * timer_tick_occurred roughly once per minute, though it doesn't have to be perfect.
+ * A simple implementation of Sign that just keeps the private keys in memory.
  *
- * Rather than using a plain ChannelManager, it is preferable to use either a SimpleArcChannelManager
- * a SimpleRefChannelManager, for conciseness. See their documentation for more details, but
- * essentially you should default to using a SimpleRefChannelManager, and use a
- * SimpleArcChannelManager when you require a ChannelManager with a static lifetime, such as when
- * you're using lightning-net-tokio.
+ * This implementation performs no policy checks and is insufficient by itself as
+ * a secure external signer.
  */
-typedef struct MUST_USE_STRUCT LDKChannelManager {
+typedef struct MUST_USE_STRUCT LDKInMemorySigner {
    /**
     * A pointer to the opaque Rust object.
     * Nearly everywhere, inner must be non-null, however in places where
     * the Rust equivalent takes an Option, it may be set to null to indicate None.
     */
-   LDKnativeChannelManager *inner;
+   LDKnativeInMemorySigner *inner;
    /**
     * Indicates that this is the only struct which contains the same pointer.
     * Rust functions which take ownership of an object provided via an argument require
     * this to be true and invalidate the object pointed to by inner.
     */
    bool is_owned;
-} LDKChannelManager;
-
-/**
- * A tuple of 2 elements. See the individual fields for the types contained.
- */
-typedef struct LDKC2Tuple_BlockHashChannelManagerZ {
-   /**
-    * The element at position 0
-    */
-   struct LDKThirtyTwoBytes a;
-   /**
-    * The element at position 1
-    */
-   struct LDKChannelManager b;
-} LDKC2Tuple_BlockHashChannelManagerZ;
+} LDKInMemorySigner;
 
 /**
- * The contents of CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ
+ * The contents of CResult_InMemorySignerDecodeErrorZ
  */
-typedef union LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZPtr {
+typedef union LDKCResult_InMemorySignerDecodeErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKC2Tuple_BlockHashChannelManagerZ *result;
+   struct LDKInMemorySigner *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
    struct LDKDecodeError *err;
-} LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZPtr;
+} LDKCResult_InMemorySignerDecodeErrorZPtr;
 
 /**
- * A CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::c_types::derived::C2Tuple_BlockHashChannelManagerZ on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * A CResult_InMemorySignerDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::chain::keysinterface::InMemorySigner on success and a crate::lightning::ln::msgs::DecodeError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ {
+typedef struct LDKCResult_InMemorySignerDecodeErrorZ {
    /**
-    * The contents of this CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ, accessible via either
+    * The contents of this CResult_InMemorySignerDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZPtr contents;
+   union LDKCResult_InMemorySignerDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ represents a success state.
+    * Whether this CResult_InMemorySignerDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ;
+} LDKCResult_InMemorySignerDecodeErrorZ;
 
 /**
- * A trait indicating an object may generate message send events
+ * A dynamically-allocated array of crate::c_types::TxOuts of arbitrary size.
+ * This corresponds to std::vector in C++
  */
-typedef struct LDKMessageSendEventsProvider {
-   /**
-    * An opaque pointer which is passed to your function implementations as an argument.
-    * This has no meaning in the LDK, and can be NULL or any other value.
-    */
-   void *this_arg;
+typedef struct LDKCVec_TxOutZ {
    /**
-    * Gets the list of pending events which were generated by previous actions, clearing the list
-    * in the process.
+    * The elements in the array.
+    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
     */
-   struct LDKCVec_MessageSendEventZ (*get_and_clear_pending_msg_events)(const void *this_arg);
+   struct LDKTxOut *data;
    /**
-    * Frees any resources associated with this object given its this_arg pointer.
-    * Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
+    * The number of elements pointed to by `data`.
     */
-   void (*free)(void *this_arg);
-} LDKMessageSendEventsProvider;
+   uintptr_t datalen;
+} LDKCVec_TxOutZ;
 
 /**
- * A trait indicating an object may generate events
+ * The contents of CResult_TransactionNoneZ
  */
-typedef struct LDKEventsProvider {
-   /**
-    * An opaque pointer which is passed to your function implementations as an argument.
-    * This has no meaning in the LDK, and can be NULL or any other value.
-    */
-   void *this_arg;
+typedef union LDKCResult_TransactionNoneZPtr {
    /**
-    * Gets the list of pending events which were generated by previous actions, clearing the list
-    * in the process.
+    * A pointer to the contents in the success state.
+    * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKCVec_EventZ (*get_and_clear_pending_events)(const void *this_arg);
+   struct LDKTransaction *result;
    /**
-    * Frees any resources associated with this object given its this_arg pointer.
-    * Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
+    * Note that this value is always NULL, as there are no contents in the Err variant
     */
-   void (*free)(void *this_arg);
-} LDKEventsProvider;
-
-
+   void *err;
+} LDKCResult_TransactionNoneZPtr;
 
 /**
- * Configuration we set when applicable.
- *
- * Default::default() provides sane defaults.
+ * A CResult_TransactionNoneZ represents the result of a fallible operation,
+ * containing a crate::c_types::Transaction on success and a () on failure.
+ * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct MUST_USE_STRUCT LDKChannelHandshakeConfig {
+typedef struct LDKCResult_TransactionNoneZ {
    /**
-    * A pointer to the opaque Rust object.
-    * Nearly everywhere, inner must be non-null, however in places where
-    * the Rust equivalent takes an Option, it may be set to null to indicate None.
+    * The contents of this CResult_TransactionNoneZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   LDKnativeChannelHandshakeConfig *inner;
+   union LDKCResult_TransactionNoneZPtr contents;
    /**
-    * Indicates that this is the only struct which contains the same pointer.
-    * Rust functions which take ownership of an object provided via an argument require
-    * this to be true and invalidate the object pointed to by inner.
+    * Whether this CResult_TransactionNoneZ represents a success state.
     */
-   bool is_owned;
-} LDKChannelHandshakeConfig;
-
-
+   bool result_ok;
+} LDKCResult_TransactionNoneZ;
 
 /**
- * Optional channel limits which are applied during channel creation.
- *
- * These limits are only applied to our counterparty's limits, not our own.
- *
- * Use 0/<type>::max_value() as appropriate to skip checking.
- *
- * Provides sane defaults for most configurations.
- *
- * Most additional limits are disabled except those with which specify a default in individual
- * field documentation. Note that this may result in barely-usable channels, but since they
- * are applied mostly only to incoming channels that's not much of a problem.
+ * The contents of CResult_NoneErrorZ
  */
-typedef struct MUST_USE_STRUCT LDKChannelHandshakeLimits {
+typedef union LDKCResult_NoneErrorZPtr {
    /**
-    * A pointer to the opaque Rust object.
-    * Nearly everywhere, inner must be non-null, however in places where
-    * the Rust equivalent takes an Option, it may be set to null to indicate None.
+    * Note that this value is always NULL, as there are no contents in the OK variant
     */
-   LDKnativeChannelHandshakeLimits *inner;
+   void *result;
    /**
-    * Indicates that this is the only struct which contains the same pointer.
-    * Rust functions which take ownership of an object provided via an argument require
-    * this to be true and invalidate the object pointed to by inner.
+    * A pointer to the contents in the error state.
+    * Reading from this pointer when `result_ok` is set is undefined.
     */
-   bool is_owned;
-} LDKChannelHandshakeLimits;
-
-
+   enum LDKIOError *err;
+} LDKCResult_NoneErrorZPtr;
 
 /**
- * Top-level config which holds ChannelHandshakeLimits and ChannelConfig.
- *
- * Default::default() provides sane defaults for most configurations
- * (but currently with 0 relay fees!)
+ * A CResult_NoneErrorZ represents the result of a fallible operation,
+ * containing a () on success and a crate::c_types::IOError on failure.
+ * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct MUST_USE_STRUCT LDKUserConfig {
+typedef struct LDKCResult_NoneErrorZ {
    /**
-    * A pointer to the opaque Rust object.
-    * Nearly everywhere, inner must be non-null, however in places where
-    * the Rust equivalent takes an Option, it may be set to null to indicate None.
+    * The contents of this CResult_NoneErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   LDKnativeUserConfig *inner;
+   union LDKCResult_NoneErrorZPtr contents;
    /**
-    * Indicates that this is the only struct which contains the same pointer.
-    * Rust functions which take ownership of an object provided via an argument require
-    * this to be true and invalidate the object pointed to by inner.
+    * Whether this CResult_NoneErrorZ represents a success state.
     */
-   bool is_owned;
-} LDKUserConfig;
+   bool result_ok;
+} LDKCResult_NoneErrorZ;
 
 /**
- * The `Access` trait defines behavior for accessing chain data and state, such as blocks and
- * UTXOs.
+ * A dynamically-allocated array of crate::c_types::derived::C2Tuple_BlockHashChannelMonitorZs of arbitrary size.
+ * This corresponds to std::vector in C++
  */
-typedef struct LDKAccess {
-   /**
-    * An opaque pointer which is passed to your function implementations as an argument.
-    * This has no meaning in the LDK, and can be NULL or any other value.
-    */
-   void *this_arg;
+typedef struct LDKCVec_C2Tuple_BlockHashChannelMonitorZZ {
    /**
-    * Returns the transaction output of a funding transaction encoded by [`short_channel_id`].
-    * Returns an error if `genesis_hash` is for a different chain or if such a transaction output
-    * is unknown.
-    *
-    * [`short_channel_id`]: https://github.com/lightningnetwork/lightning-rfc/blob/master/07-routing-gossip.md#definition-of-short_channel_id
+    * The elements in the array.
+    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
     */
-   struct LDKCResult_TxOutAccessErrorZ (*get_utxo)(const void *this_arg, const uint8_t (*genesis_hash)[32], uint64_t short_channel_id);
+   struct LDKC2Tuple_BlockHashChannelMonitorZ *data;
    /**
-    * Frees any resources associated with this object given its this_arg pointer.
-    * Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
+    * The number of elements pointed to by `data`.
     */
-   void (*free)(void *this_arg);
-} LDKAccess;
+   uintptr_t datalen;
+} LDKCVec_C2Tuple_BlockHashChannelMonitorZZ;
 
 /**
- * The `Listen` trait is used to notify when blocks have been connected or disconnected from the
- * chain.
- *
- * Useful when needing to replay chain data upon startup or as new chain events occur. Clients
- * sourcing chain data using a block-oriented API should prefer this interface over [`Confirm`].
- * Such clients fetch the entire header chain whereas clients using [`Confirm`] only fetch headers
- * when needed.
+ * The contents of CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ
  */
-typedef struct LDKListen {
+typedef union LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZPtr {
    /**
-    * An opaque pointer which is passed to your function implementations as an argument.
-    * This has no meaning in the LDK, and can be NULL or any other value.
+    * A pointer to the contents in the success state.
+    * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   void *this_arg;
+   struct LDKCVec_C2Tuple_BlockHashChannelMonitorZZ *result;
    /**
-    * Notifies the listener that a block was added at the given height.
+    * A pointer to the contents in the error state.
+    * Reading from this pointer when `result_ok` is set is undefined.
     */
-   void (*block_connected)(const void *this_arg, struct LDKu8slice block, uint32_t height);
+   enum LDKIOError *err;
+} LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZPtr;
+
+/**
+ * A CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ represents the result of a fallible operation,
+ * containing a crate::c_types::derived::CVec_C2Tuple_BlockHashChannelMonitorZZ on success and a crate::c_types::IOError on failure.
+ * `result_ok` indicates the overall state, and the contents are provided via `contents`.
+ */
+typedef struct LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ {
    /**
-    * Notifies the listener that a block was removed at the given height.
+    * The contents of this CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   void (*block_disconnected)(const void *this_arg, const uint8_t (*header)[80], uint32_t height);
+   union LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZPtr contents;
    /**
-    * Frees any resources associated with this object given its this_arg pointer.
-    * Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
+    * Whether this CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ represents a success state.
     */
-   void (*free)(void *this_arg);
-} LDKListen;
+   bool result_ok;
+} LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ;
 
 /**
- * The `Confirm` trait is used to notify when transactions have been confirmed on chain or
- * unconfirmed during a chain reorganization.
- *
- * Clients sourcing chain data using a transaction-oriented API should prefer this interface over
- * [`Listen`]. For instance, an Electrum client may implement [`Filter`] by subscribing to activity
- * related to registered transactions and outputs. Upon notification, it would pass along the
- * matching transactions using this interface.
- *
- * # Use
- *
- * The intended use is as follows:
- * - Call [`transactions_confirmed`] to process any on-chain activity of interest.
- * - Call [`transaction_unconfirmed`] to process any transaction returned by [`get_relevant_txids`]
- *   that has been reorganized out of the chain.
- * - Call [`best_block_updated`] whenever a new chain tip becomes available.
- *
- * # Order
- *
- * Clients must call these methods in chain order. Specifically:
- * - Transactions confirmed in a block must be given before transactions confirmed in a later
- *   block.
- * - Dependent transactions within the same block must be given in topological order, possibly in
- *   separate calls.
- * - Unconfirmed transactions must be given after the original confirmations and before any
- *   reconfirmation.
- *
- * See individual method documentation for further details.
- *
- * [`transactions_confirmed`]: Self::transactions_confirmed
- * [`transaction_unconfirmed`]: Self::transaction_unconfirmed
- * [`best_block_updated`]: Self::best_block_updated
- * [`get_relevant_txids`]: Self::get_relevant_txids
+ * Indicates an error on the client's part (usually some variant of attempting to use too-low or
+ * too-high values)
  */
-typedef struct LDKConfirm {
+typedef enum LDKAPIError_Tag {
    /**
-    * An opaque pointer which is passed to your function implementations as an argument.
-    * This has no meaning in the LDK, and can be NULL or any other value.
+    * Indicates the API was wholly misused (see err for more). Cases where these can be returned
+    * are documented, but generally indicates some precondition of a function was violated.
     */
-   void *this_arg;
+   LDKAPIError_APIMisuseError,
    /**
-    * Processes transactions confirmed in a block with a given header and height.
-    *
-    * Should be called for any transactions registered by [`Filter::register_tx`] or any
-    * transactions spending an output registered by [`Filter::register_output`]. Such transactions
-    * appearing in the same block do not need to be included in the same call; instead, multiple
-    * calls with additional transactions may be made so long as they are made in [chain order].
-    *
-    * May be called before or after [`best_block_updated`] for the corresponding block. However,
-    * in the event of a chain reorganization, it must not be called with a `header` that is no
-    * longer in the chain as of the last call to [`best_block_updated`].
-    *
-    * [chain order]: Self#order
-    * [`best_block_updated`]: Self::best_block_updated
+    * Due to a high feerate, we were unable to complete the request.
+    * For example, this may be returned if the feerate implies we cannot open a channel at the
+    * requested value, but opening a larger channel would succeed.
     */
-   void (*transactions_confirmed)(const void *this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height);
+   LDKAPIError_FeeRateTooHigh,
    /**
-    * Processes a transaction that is no longer confirmed as result of a chain reorganization.
-    *
-    * Should be called for any transaction returned by [`get_relevant_txids`] if it has been
-    * reorganized out of the best chain. Once called, the given transaction should not