]> git.bitcoin.ninja Git - ldk-c-bindings/commitdiff
Regenerate auto-generated bindings 2021-04-bp-inclusion
authorMatt Corallo <git@bluematt.me>
Wed, 2 Jun 2021 16:27:29 +0000 (16:27 +0000)
committerMatt Corallo <git@bluematt.me>
Wed, 2 Jun 2021 19:19:35 +0000 (19:19 +0000)
14 files changed:
lightning-c-bindings/include/ldk_rust_types.h
lightning-c-bindings/include/lightning.h
lightning-c-bindings/include/lightningpp.hpp
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/channelmonitor.rs
lightning-c-bindings/src/lightning/chain/keysinterface.rs
lightning-c-bindings/src/lightning/chain/mod.rs
lightning-c-bindings/src/lightning/ln/msgs.rs
lightning-c-bindings/src/lightning/ln/peer_handler.rs
lightning-c-bindings/src/lightning/util/events.rs
lightning-c-bindings/src/lightning/util/logger.rs
lightning-c-bindings/src/lightning_background_processor.rs [new file with mode: 0644]

index 7dc569b42b414f4e0638b504fe6e0bd35c15ec7d..3138c9e69921a1dc30ac49084bae644e34f167f6 100644 (file)
 #else
 #define NONNULL_PTR
 #endif
-struct nativeChannelHandshakeConfigOpaque;
-typedef struct nativeChannelHandshakeConfigOpaque LDKnativeChannelHandshakeConfig;
-struct nativeChannelHandshakeLimitsOpaque;
-typedef struct nativeChannelHandshakeLimitsOpaque LDKnativeChannelHandshakeLimits;
-struct nativeChannelConfigOpaque;
-typedef struct nativeChannelConfigOpaque LDKnativeChannelConfig;
-struct nativeUserConfigOpaque;
-typedef struct nativeUserConfigOpaque LDKnativeUserConfig;
-struct nativeOutPointOpaque;
-typedef struct nativeOutPointOpaque LDKnativeOutPoint;
 struct nativeTxCreationKeysOpaque;
 typedef struct nativeTxCreationKeysOpaque LDKnativeTxCreationKeys;
 struct nativeChannelPublicKeysOpaque;
@@ -40,6 +30,56 @@ struct nativeCommitmentTransactionOpaque;
 typedef struct nativeCommitmentTransactionOpaque LDKnativeCommitmentTransaction;
 struct nativeTrustedCommitmentTransactionOpaque;
 typedef struct nativeTrustedCommitmentTransactionOpaque LDKnativeTrustedCommitmentTransaction;
+struct nativeBackgroundProcessorOpaque;
+typedef struct nativeBackgroundProcessorOpaque LDKnativeBackgroundProcessor;
+struct nativeRouteHopOpaque;
+typedef struct nativeRouteHopOpaque LDKnativeRouteHop;
+struct nativeRouteOpaque;
+typedef struct nativeRouteOpaque LDKnativeRoute;
+struct nativeRouteHintHopOpaque;
+typedef struct nativeRouteHintHopOpaque LDKnativeRouteHintHop;
+struct nativeWatchedOutputOpaque;
+typedef struct nativeWatchedOutputOpaque LDKnativeWatchedOutput;
+struct nativeInitFeaturesOpaque;
+typedef struct nativeInitFeaturesOpaque LDKnativeInitFeatures;
+struct nativeNodeFeaturesOpaque;
+typedef struct nativeNodeFeaturesOpaque LDKnativeNodeFeatures;
+struct nativeChannelFeaturesOpaque;
+typedef struct nativeChannelFeaturesOpaque LDKnativeChannelFeatures;
+struct nativeInvoiceFeaturesOpaque;
+typedef struct nativeInvoiceFeaturesOpaque LDKnativeInvoiceFeatures;
+struct nativeDelayedPaymentOutputDescriptorOpaque;
+typedef struct nativeDelayedPaymentOutputDescriptorOpaque LDKnativeDelayedPaymentOutputDescriptor;
+struct nativeStaticPaymentOutputDescriptorOpaque;
+typedef struct nativeStaticPaymentOutputDescriptorOpaque LDKnativeStaticPaymentOutputDescriptor;
+struct LDKBaseSign;
+typedef struct LDKBaseSign LDKBaseSign;
+struct nativeInMemorySignerOpaque;
+typedef struct nativeInMemorySignerOpaque LDKnativeInMemorySigner;
+struct nativeKeysManagerOpaque;
+typedef struct nativeKeysManagerOpaque LDKnativeKeysManager;
+struct nativeFilesystemPersisterOpaque;
+typedef struct nativeFilesystemPersisterOpaque LDKnativeFilesystemPersister;
+struct nativeChannelManagerOpaque;
+typedef struct nativeChannelManagerOpaque LDKnativeChannelManager;
+struct nativeChainParametersOpaque;
+typedef struct nativeChainParametersOpaque LDKnativeChainParameters;
+struct nativeBestBlockOpaque;
+typedef struct nativeBestBlockOpaque LDKnativeBestBlock;
+struct nativeChannelDetailsOpaque;
+typedef struct nativeChannelDetailsOpaque LDKnativeChannelDetails;
+struct nativeChannelManagerReadArgsOpaque;
+typedef struct nativeChannelManagerReadArgsOpaque LDKnativeChannelManagerReadArgs;
+struct nativeChannelHandshakeConfigOpaque;
+typedef struct nativeChannelHandshakeConfigOpaque LDKnativeChannelHandshakeConfig;
+struct nativeChannelHandshakeLimitsOpaque;
+typedef struct nativeChannelHandshakeLimitsOpaque LDKnativeChannelHandshakeLimits;
+struct nativeChannelConfigOpaque;
+typedef struct nativeChannelConfigOpaque LDKnativeChannelConfig;
+struct nativeUserConfigOpaque;
+typedef struct nativeUserConfigOpaque LDKnativeUserConfig;
+struct nativeOutPointOpaque;
+typedef struct nativeOutPointOpaque LDKnativeOutPoint;
 struct nativeInvoiceOpaque;
 typedef struct nativeInvoiceOpaque LDKnativeInvoice;
 struct nativeSignedRawInvoiceOpaque;
@@ -72,12 +112,6 @@ struct nativeHTLCUpdateOpaque;
 typedef struct nativeHTLCUpdateOpaque LDKnativeHTLCUpdate;
 struct nativeChannelMonitorOpaque;
 typedef struct nativeChannelMonitorOpaque LDKnativeChannelMonitor;
-struct nativeRouteHopOpaque;
-typedef struct nativeRouteHopOpaque LDKnativeRouteHop;
-struct nativeRouteOpaque;
-typedef struct nativeRouteOpaque LDKnativeRoute;
-struct nativeRouteHintHopOpaque;
-typedef struct nativeRouteHintHopOpaque LDKnativeRouteHintHop;
 struct nativeIgnoringMessageHandlerOpaque;
 typedef struct nativeIgnoringMessageHandlerOpaque LDKnativeIgnoringMessageHandler;
 struct nativeErroringMessageHandlerOpaque;
@@ -89,8 +123,6 @@ struct nativePeerHandleErrorOpaque;
 typedef struct nativePeerHandleErrorOpaque LDKnativePeerHandleError;
 struct nativePeerManagerOpaque;
 typedef struct nativePeerManagerOpaque LDKnativePeerManager;
-struct nativeWatchedOutputOpaque;
-typedef struct nativeWatchedOutputOpaque LDKnativeWatchedOutput;
 struct nativeNetworkGraphOpaque;
 typedef struct nativeNetworkGraphOpaque LDKnativeNetworkGraph;
 struct nativeLockedNetworkGraphOpaque;
@@ -107,14 +139,6 @@ struct nativeNodeAnnouncementInfoOpaque;
 typedef struct nativeNodeAnnouncementInfoOpaque LDKnativeNodeAnnouncementInfo;
 struct nativeNodeInfoOpaque;
 typedef struct nativeNodeInfoOpaque LDKnativeNodeInfo;
-struct nativeInitFeaturesOpaque;
-typedef struct nativeInitFeaturesOpaque LDKnativeInitFeatures;
-struct nativeNodeFeaturesOpaque;
-typedef struct nativeNodeFeaturesOpaque LDKnativeNodeFeatures;
-struct nativeChannelFeaturesOpaque;
-typedef struct nativeChannelFeaturesOpaque LDKnativeChannelFeatures;
-struct nativeInvoiceFeaturesOpaque;
-typedef struct nativeInvoiceFeaturesOpaque LDKnativeInvoiceFeatures;
 struct nativeDecodeErrorOpaque;
 typedef struct nativeDecodeErrorOpaque LDKnativeDecodeError;
 struct nativeInitOpaque;
@@ -185,27 +209,5 @@ struct nativeLightningErrorOpaque;
 typedef struct nativeLightningErrorOpaque LDKnativeLightningError;
 struct nativeCommitmentUpdateOpaque;
 typedef struct nativeCommitmentUpdateOpaque LDKnativeCommitmentUpdate;
-struct nativeDelayedPaymentOutputDescriptorOpaque;
-typedef struct nativeDelayedPaymentOutputDescriptorOpaque LDKnativeDelayedPaymentOutputDescriptor;
-struct nativeStaticPaymentOutputDescriptorOpaque;
-typedef struct nativeStaticPaymentOutputDescriptorOpaque LDKnativeStaticPaymentOutputDescriptor;
-struct LDKBaseSign;
-typedef struct LDKBaseSign LDKBaseSign;
-struct nativeInMemorySignerOpaque;
-typedef struct nativeInMemorySignerOpaque LDKnativeInMemorySigner;
-struct nativeKeysManagerOpaque;
-typedef struct nativeKeysManagerOpaque LDKnativeKeysManager;
 struct nativeChainMonitorOpaque;
 typedef struct nativeChainMonitorOpaque LDKnativeChainMonitor;
-struct nativeFilesystemPersisterOpaque;
-typedef struct nativeFilesystemPersisterOpaque LDKnativeFilesystemPersister;
-struct nativeChannelManagerOpaque;
-typedef struct nativeChannelManagerOpaque LDKnativeChannelManager;
-struct nativeChainParametersOpaque;
-typedef struct nativeChainParametersOpaque LDKnativeChainParameters;
-struct nativeBestBlockOpaque;
-typedef struct nativeBestBlockOpaque LDKnativeBestBlock;
-struct nativeChannelDetailsOpaque;
-typedef struct nativeChannelDetailsOpaque LDKnativeChannelDetails;
-struct nativeChannelManagerReadArgsOpaque;
-typedef struct nativeChannelManagerReadArgsOpaque LDKnativeChannelManagerReadArgs;
index 455cae8ade37eefbfab884db34be513f1954a7f6..c6c97b7cadad2da7353c1d9d013ba2432d43ecb1 100644 (file)
@@ -458,136 +458,6 @@ typedef struct LDKTxOut {
    uint64_t value;
 } LDKTxOut;
 
-
-
-/**
- * Options which apply on a per-channel basis and may change at runtime or based on negotiation
- * with our counterparty.
- */
-typedef struct MUST_USE_STRUCT LDKChannelConfig {
-   /**
-    * 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.
-    */
-   LDKnativeChannelConfig *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;
-} LDKChannelConfig;
-
-
-
-/**
- * An error in decoding a message or struct.
- */
-typedef struct MUST_USE_STRUCT LDKDecodeError {
-   /**
-    * 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.
-    */
-   LDKnativeDecodeError *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;
-} LDKDecodeError;
-
-/**
- * The contents of CResult_ChannelConfigDecodeErrorZ
- */
-typedef union LDKCResult_ChannelConfigDecodeErrorZPtr {
-   /**
-    * A pointer to the contents in the success state.
-    * Reading from this pointer when `result_ok` is not set is undefined.
-    */
-   struct LDKChannelConfig *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_ChannelConfigDecodeErrorZPtr;
-
-/**
- * A CResult_ChannelConfigDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::util::config::ChannelConfig 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_ChannelConfigDecodeErrorZ {
-   /**
-    * The contents of this CResult_ChannelConfigDecodeErrorZ, accessible via either
-    * `err` or `result` depending on the state of `result_ok`.
-    */
-   union LDKCResult_ChannelConfigDecodeErrorZPtr contents;
-   /**
-    * Whether this CResult_ChannelConfigDecodeErrorZ represents a success state.
-    */
-   bool result_ok;
-} LDKCResult_ChannelConfigDecodeErrorZ;
-
-
-
-/**
- * A reference to a transaction output.
- *
- * Differs from bitcoin::blockdata::transaction::OutPoint as the index is a u16 instead of u32
- * due to LN's restrictions on index values. Should reduce (possibly) unsafe conversions this way.
- */
-typedef struct MUST_USE_STRUCT LDKOutPoint {
-   /**
-    * 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.
-    */
-   LDKnativeOutPoint *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;
-} LDKOutPoint;
-
-/**
- * The contents of CResult_OutPointDecodeErrorZ
- */
-typedef union LDKCResult_OutPointDecodeErrorZPtr {
-   /**
-    * A pointer to the contents in the success state.
-    * Reading from this pointer when `result_ok` is not set is undefined.
-    */
-   struct LDKOutPoint *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_OutPointDecodeErrorZPtr;
-
-/**
- * A CResult_OutPointDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::chain::transaction::OutPoint 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_OutPointDecodeErrorZ {
-   /**
-    * The contents of this CResult_OutPointDecodeErrorZ, accessible via either
-    * `err` or `result` depending on the state of `result_ok`.
-    */
-   union LDKCResult_OutPointDecodeErrorZPtr contents;
-   /**
-    * Whether this CResult_OutPointDecodeErrorZ represents a success state.
-    */
-   bool result_ok;
-} LDKCResult_OutPointDecodeErrorZ;
-
 /**
  * Represents a valid secp256k1 secret key serialized as a 32 byte array.
  */
@@ -704,6 +574,26 @@ typedef struct MUST_USE_STRUCT LDKTxCreationKeys {
    bool is_owned;
 } LDKTxCreationKeys;
 
+
+
+/**
+ * An error in decoding a message or struct.
+ */
+typedef struct MUST_USE_STRUCT LDKDecodeError {
+   /**
+    * 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.
+    */
+   LDKnativeDecodeError *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;
+} LDKDecodeError;
+
 /**
  * The contents of CResult_TxCreationKeysDecodeErrorZ
  */
@@ -1295,6440 +1185,6550 @@ typedef struct LDKCResult_CVec_SignatureZNoneZ {
 } LDKCResult_CVec_SignatureZNoneZ;
 
 /**
- * The contents of CResult_SiPrefixNoneZ
+ * The contents of CResult_NoneErrorZ
  */
-typedef union LDKCResult_SiPrefixNoneZPtr {
+typedef union LDKCResult_NoneErrorZPtr {
    /**
-    * 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
     */
-   enum LDKSiPrefix *result;
+   void *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_SiPrefixNoneZPtr;
+   enum LDKIOError *err;
+} LDKCResult_NoneErrorZPtr;
 
 /**
- * A CResult_SiPrefixNoneZ represents the result of a fallible operation,
- * containing a crate::lightning_invoice::SiPrefix on success and a () on failure.
+ * 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 LDKCResult_SiPrefixNoneZ {
+typedef struct LDKCResult_NoneErrorZ {
    /**
-    * The contents of this CResult_SiPrefixNoneZ, accessible via either
+    * The contents of this CResult_NoneErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_SiPrefixNoneZPtr contents;
+   union LDKCResult_NoneErrorZPtr contents;
    /**
-    * Whether this CResult_SiPrefixNoneZ represents a success state.
+    * Whether this CResult_NoneErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_SiPrefixNoneZ;
+} LDKCResult_NoneErrorZ;
 
 
 
 /**
- * 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)`
+ * A hop in a route
  */
-typedef struct MUST_USE_STRUCT LDKInvoice {
+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.
     */
-   LDKnativeInvoice *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;
-} LDKInvoice;
+} LDKRouteHop;
 
 /**
- * The contents of CResult_InvoiceNoneZ
+ * The contents of CResult_RouteHopDecodeErrorZ
  */
-typedef union LDKCResult_InvoiceNoneZPtr {
+typedef union LDKCResult_RouteHopDecodeErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKInvoice *result;
+   struct LDKRouteHop *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_InvoiceNoneZPtr;
+   struct LDKDecodeError *err;
+} LDKCResult_RouteHopDecodeErrorZPtr;
 
 /**
- * A CResult_InvoiceNoneZ represents the result of a fallible operation,
- * containing a crate::lightning_invoice::Invoice on success and a () on failure.
+ * A CResult_RouteHopDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::routing::router::RouteHop 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_InvoiceNoneZ {
+typedef struct LDKCResult_RouteHopDecodeErrorZ {
    /**
-    * The contents of this CResult_InvoiceNoneZ, accessible via either
+    * The contents of this CResult_RouteHopDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_InvoiceNoneZPtr contents;
+   union LDKCResult_RouteHopDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_InvoiceNoneZ represents a success state.
+    * Whether this CResult_RouteHopDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_InvoiceNoneZ;
-
-
+} LDKCResult_RouteHopDecodeErrorZ;
 
 /**
- * Represents a signed `RawInvoice` with cached hash. The signature is not checked and may be
- * invalid.
- *
- * # Invariants
- * The hash has to be either from the deserialized invoice or from the serialized `raw_invoice`.
+ * A dynamically-allocated array of crate::lightning::routing::router::RouteHops of arbitrary size.
+ * This corresponds to std::vector in C++
  */
-typedef struct MUST_USE_STRUCT LDKSignedRawInvoice {
+typedef struct LDKCVec_RouteHopZ {
    /**
-    * 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().
     */
-   LDKnativeSignedRawInvoice *inner;
+   struct LDKRouteHop *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;
-} LDKSignedRawInvoice;
+   uintptr_t datalen;
+} LDKCVec_RouteHopZ;
 
 /**
- * The contents of CResult_SignedRawInvoiceNoneZ
+ * A dynamically-allocated array of crate::c_types::derived::CVec_RouteHopZs of arbitrary size.
+ * This corresponds to std::vector in C++
  */
-typedef union LDKCResult_SignedRawInvoiceNoneZPtr {
+typedef struct LDKCVec_CVec_RouteHopZZ {
    /**
-    * 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 LDKSignedRawInvoice *result;
-   /**
-    * Note that this value is always NULL, as there are no contents in the Err variant
-    */
-   void *err;
-} LDKCResult_SignedRawInvoiceNoneZPtr;
-
-/**
- * A CResult_SignedRawInvoiceNoneZ represents the result of a fallible operation,
- * containing a crate::lightning_invoice::SignedRawInvoice on success and a () on failure.
- * `result_ok` indicates the overall state, and the contents are provided via `contents`.
- */
-typedef struct LDKCResult_SignedRawInvoiceNoneZ {
-   /**
-    * The contents of this CResult_SignedRawInvoiceNoneZ, accessible via either
-    * `err` or `result` depending on the state of `result_ok`.
-    */
-   union LDKCResult_SignedRawInvoiceNoneZPtr contents;
+   struct LDKCVec_RouteHopZ *data;
    /**
-    * Whether this CResult_SignedRawInvoiceNoneZ represents a success state.
+    * The number of elements pointed to by `data`.
     */
-   bool result_ok;
-} LDKCResult_SignedRawInvoiceNoneZ;
+   uintptr_t datalen;
+} LDKCVec_CVec_RouteHopZZ;
 
 
 
 /**
- * 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`.
+ * 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 LDKRawInvoice {
+typedef struct MUST_USE_STRUCT LDKRoute {
    /**
     * 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.
     */
-   LDKnativeRawInvoice *inner;
+   LDKnativeRoute *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;
-} LDKRawInvoice;
+} LDKRoute;
 
 /**
- * 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.
+ * The contents of CResult_RouteDecodeErrorZ
  */
-typedef struct LDKThirtyTwoBytes {
+typedef union LDKCResult_RouteDecodeErrorZPtr {
    /**
-    * The thirty-two bytes
+    * A pointer to the contents in the success state.
+    * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   uint8_t data[32];
-} LDKThirtyTwoBytes;
-
-
+   struct LDKRoute *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_RouteDecodeErrorZPtr;
 
 /**
- * Recoverable signature
+ * 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 MUST_USE_STRUCT LDKInvoiceSignature {
+typedef struct LDKCResult_RouteDecodeErrorZ {
    /**
-    * 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_RouteDecodeErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   LDKnativeInvoiceSignature *inner;
+   union LDKCResult_RouteDecodeErrorZPtr 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_RouteDecodeErrorZ represents a success state.
     */
-   bool is_owned;
-} LDKInvoiceSignature;
+   bool result_ok;
+} LDKCResult_RouteDecodeErrorZ;
 
 /**
- * A tuple of 3 elements. See the individual fields for the types contained.
+ * An enum which can either contain a u64 or not
  */
-typedef struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ {
+typedef enum LDKCOption_u64Z_Tag {
    /**
-    * The element at position 0
+    * When we're in this state, this COption_u64Z contains a u64
     */
-   struct LDKRawInvoice a;
+   LDKCOption_u64Z_Some,
    /**
-    * The element at position 1
+    * When we're in this state, this COption_u64Z contains nothing
     */
-   struct LDKThirtyTwoBytes b;
+   LDKCOption_u64Z_None,
    /**
-    * The element at position 2
+    * Must be last for serialization purposes
     */
-   struct LDKInvoiceSignature c;
-} LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ;
+   LDKCOption_u64Z_Sentinel,
+} LDKCOption_u64Z_Tag;
+
+typedef struct LDKCOption_u64Z {
+   LDKCOption_u64Z_Tag tag;
+   union {
+      struct {
+         uint64_t some;
+      };
+   };
+} LDKCOption_u64Z;
 
 
 
 /**
- * Payee public key
+ * Details of a channel, as returned by ChannelManager::list_channels and ChannelManager::list_usable_channels
  */
-typedef struct MUST_USE_STRUCT LDKPayeePubKey {
+typedef struct MUST_USE_STRUCT LDKChannelDetails {
    /**
     * 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.
     */
-   LDKnativePayeePubKey *inner;
+   LDKnativeChannelDetails *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;
-} LDKPayeePubKey;
-
-/**
- * The contents of CResult_PayeePubKeyErrorZ
- */
-typedef union LDKCResult_PayeePubKeyErrorZPtr {
-   /**
-    * A pointer to the contents in the success state.
-    * Reading from this pointer when `result_ok` is not set is undefined.
-    */
-   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;
+} LDKChannelDetails;
 
 /**
- * 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`.
+ * A dynamically-allocated array of crate::lightning::ln::channelmanager::ChannelDetailss of arbitrary size.
+ * This corresponds to std::vector in C++
  */
-typedef struct LDKCResult_PayeePubKeyErrorZ {
+typedef struct LDKCVec_ChannelDetailsZ {
    /**
-    * The contents of this CResult_PayeePubKeyErrorZ, 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_PayeePubKeyErrorZPtr contents;
+   struct LDKChannelDetails *data;
    /**
-    * Whether this CResult_PayeePubKeyErrorZ represents a success state.
+    * The number of elements pointed to by `data`.
     */
-   bool result_ok;
-} LDKCResult_PayeePubKeyErrorZ;
+   uintptr_t datalen;
+} LDKCVec_ChannelDetailsZ;
 
 
 
 /**
- * Private routing information
- *
- * # Invariants
- * The encoded route has to be <1024 5bit characters long (<=639 bytes or <=12 hops)
- *
+ * A channel descriptor which provides a last-hop route to get_route
  */
-typedef struct MUST_USE_STRUCT LDKRouteHint {
+typedef struct MUST_USE_STRUCT LDKRouteHintHop {
    /**
     * 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.
     */
-   LDKnativeRouteHint *inner;
+   LDKnativeRouteHintHop *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;
-} LDKRouteHint;
+} LDKRouteHintHop;
 
 /**
- * A dynamically-allocated array of crate::lightning_invoice::RouteHints 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_RouteHintZ {
+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 LDKRouteHint *data;
+   struct LDKRouteHintHop *data;
    /**
     * The number of elements pointed to by `data`.
     */
    uintptr_t datalen;
-} LDKCVec_RouteHintZ;
-
-/**
- * An enum which can either contain a u64 or not
- */
-typedef enum LDKCOption_u64Z_Tag {
-   /**
-    * When we're in this state, this COption_u64Z contains a u64
-    */
-   LDKCOption_u64Z_Some,
-   /**
-    * When we're in this state, this COption_u64Z contains nothing
-    */
-   LDKCOption_u64Z_None,
-   /**
-    * 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;
+} LDKCVec_RouteHintHopZ;
 
 
 
 /**
- * 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.
+ * An Err type for failure to process messages.
  */
-typedef struct MUST_USE_STRUCT LDKPositiveTimestamp {
+typedef struct MUST_USE_STRUCT LDKLightningError {
    /**
     * 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.
     */
-   LDKnativePositiveTimestamp *inner;
+   LDKnativeLightningError *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;
-} LDKPositiveTimestamp;
+} LDKLightningError;
 
 /**
- * The contents of CResult_PositiveTimestampCreationErrorZ
+ * The contents of CResult_RouteLightningErrorZ
  */
-typedef union LDKCResult_PositiveTimestampCreationErrorZPtr {
+typedef union LDKCResult_RouteLightningErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKPositiveTimestamp *result;
+   struct LDKRoute *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
-   enum LDKCreationError *err;
-} LDKCResult_PositiveTimestampCreationErrorZPtr;
+   struct LDKLightningError *err;
+} LDKCResult_RouteLightningErrorZPtr;
 
 /**
- * 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.
+ * 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_PositiveTimestampCreationErrorZ {
+typedef struct LDKCResult_RouteLightningErrorZ {
    /**
-    * The contents of this CResult_PositiveTimestampCreationErrorZ, accessible via either
+    * The contents of this CResult_RouteLightningErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_PositiveTimestampCreationErrorZPtr contents;
+   union LDKCResult_RouteLightningErrorZPtr contents;
    /**
-    * Whether this CResult_PositiveTimestampCreationErrorZ represents a success state.
+    * Whether this CResult_RouteLightningErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_PositiveTimestampCreationErrorZ;
+} LDKCResult_RouteLightningErrorZ;
 
 /**
- * The contents of CResult_NoneSemanticErrorZ
+ * The contents of CResult_TxOutAccessErrorZ
  */
-typedef union LDKCResult_NoneSemanticErrorZPtr {
+typedef union LDKCResult_TxOutAccessErrorZPtr {
    /**
-    * 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 LDKTxOut *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
-   enum LDKSemanticError *err;
-} LDKCResult_NoneSemanticErrorZPtr;
+   enum LDKAccessError *err;
+} LDKCResult_TxOutAccessErrorZPtr;
 
 /**
- * A CResult_NoneSemanticErrorZ represents the result of a fallible operation,
- * containing a () on success and a crate::lightning_invoice::SemanticError 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_NoneSemanticErrorZ {
+typedef struct LDKCResult_TxOutAccessErrorZ {
    /**
-    * The contents of this CResult_NoneSemanticErrorZ, accessible via either
+    * The contents of this CResult_TxOutAccessErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_NoneSemanticErrorZPtr contents;
+   union LDKCResult_TxOutAccessErrorZPtr contents;
    /**
-    * Whether this CResult_NoneSemanticErrorZ represents a success state.
+    * Whether this CResult_TxOutAccessErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_NoneSemanticErrorZ;
+} LDKCResult_TxOutAccessErrorZ;
 
 /**
- * The contents of CResult_InvoiceSemanticErrorZ
+ * A tuple of 2 elements. See the individual fields for the types contained.
  */
-typedef union LDKCResult_InvoiceSemanticErrorZPtr {
+typedef struct LDKC2Tuple_usizeTransactionZ {
    /**
-    * A pointer to the contents in the success state.
-    * Reading from this pointer when `result_ok` is not set is undefined.
+    * The element at position 0
     */
-   struct LDKInvoice *result;
+   uintptr_t a;
    /**
-    * A pointer to the contents in the error state.
-    * Reading from this pointer when `result_ok` is set is undefined.
+    * The element at position 1
     */
-   enum LDKSemanticError *err;
-} LDKCResult_InvoiceSemanticErrorZPtr;
+   struct LDKTransaction b;
+} LDKC2Tuple_usizeTransactionZ;
 
 /**
- * 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`.
+ * A dynamically-allocated array of crate::c_types::derived::C2Tuple_usizeTransactionZs of arbitrary size.
+ * This corresponds to std::vector in C++
  */
-typedef struct LDKCResult_InvoiceSemanticErrorZ {
+typedef struct LDKCVec_C2Tuple_usizeTransactionZZ {
    /**
-    * The contents of this CResult_InvoiceSemanticErrorZ, 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_InvoiceSemanticErrorZPtr contents;
+   struct LDKC2Tuple_usizeTransactionZ *data;
    /**
-    * Whether this CResult_InvoiceSemanticErrorZ represents a success state.
+    * The number of elements pointed to by `data`.
     */
-   bool result_ok;
-} LDKCResult_InvoiceSemanticErrorZ;
-
+   uintptr_t datalen;
+} LDKCVec_C2Tuple_usizeTransactionZZ;
 
+/**
+ * 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;
 
 /**
- * Description string
- *
- * # Invariants
- * The description can be at most 639 __bytes__ long
+ * A dynamically-allocated array of crate::c_types::ThirtyTwoBytess of arbitrary size.
+ * This corresponds to std::vector in C++
  */
-typedef struct MUST_USE_STRUCT LDKDescription {
+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().
     */
-   LDKnativeDescription *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;
-} LDKDescription;
+   uintptr_t datalen;
+} LDKCVec_TxidZ;
 
 /**
- * The contents of CResult_DescriptionCreationErrorZ
+ * The contents of CResult_NoneChannelMonitorUpdateErrZ
  */
-typedef union LDKCResult_DescriptionCreationErrorZPtr {
+typedef union LDKCResult_NoneChannelMonitorUpdateErrZPtr {
    /**
-    * 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 LDKDescription *result;
+   void *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
-   enum LDKCreationError *err;
-} LDKCResult_DescriptionCreationErrorZPtr;
+   enum LDKChannelMonitorUpdateErr *err;
+} LDKCResult_NoneChannelMonitorUpdateErrZPtr;
 
 /**
- * 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.
+ * 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 LDKCResult_DescriptionCreationErrorZ {
+typedef struct LDKCResult_NoneChannelMonitorUpdateErrZ {
    /**
-    * The contents of this CResult_DescriptionCreationErrorZ, accessible via either
+    * The contents of this CResult_NoneChannelMonitorUpdateErrZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_DescriptionCreationErrorZPtr contents;
+   union LDKCResult_NoneChannelMonitorUpdateErrZPtr contents;
    /**
-    * Whether this CResult_DescriptionCreationErrorZ represents a success state.
+    * Whether this CResult_NoneChannelMonitorUpdateErrZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_DescriptionCreationErrorZ;
+} LDKCResult_NoneChannelMonitorUpdateErrZ;
 
 
 
 /**
- * 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
+ * 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 struct MUST_USE_STRUCT LDKExpiryTime {
+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.
     */
-   LDKnativeExpiryTime *inner;
+   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;
-} LDKExpiryTime;
-
-/**
- * The contents of CResult_ExpiryTimeCreationErrorZ
- */
-typedef union LDKCResult_ExpiryTimeCreationErrorZPtr {
-   /**
-    * A pointer to the contents in the success state.
-    * Reading from this pointer when `result_ok` is not set is undefined.
-    */
-   struct LDKExpiryTime *result;
-   /**
-    * A pointer to the contents in the error state.
-    * Reading from this pointer when `result_ok` is set is undefined.
-    */
-   enum LDKCreationError *err;
-} LDKCResult_ExpiryTimeCreationErrorZPtr;
-
-/**
- * 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 LDKCResult_ExpiryTimeCreationErrorZ {
-   /**
-    * The contents of this CResult_ExpiryTimeCreationErrorZ, accessible via either
-    * `err` or `result` depending on the state of `result_ok`.
-    */
-   union LDKCResult_ExpiryTimeCreationErrorZPtr contents;
-   /**
-    * Whether this CResult_ExpiryTimeCreationErrorZ represents a success state.
-    */
-   bool result_ok;
-} LDKCResult_ExpiryTimeCreationErrorZ;
+} LDKHTLCUpdate;
 
 
 
 /**
- * A channel descriptor which provides a last-hop route to get_route
+ * A reference to a transaction output.
+ *
+ * Differs from bitcoin::blockdata::transaction::OutPoint as the index is a u16 instead of u32
+ * due to LN's restrictions on index values. Should reduce (possibly) unsafe conversions this way.
  */
-typedef struct MUST_USE_STRUCT LDKRouteHintHop {
+typedef struct MUST_USE_STRUCT LDKOutPoint {
    /**
     * 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.
     */
-   LDKnativeRouteHintHop *inner;
+   LDKnativeOutPoint *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;
-} LDKRouteHintHop;
+} LDKOutPoint;
 
 /**
- * A dynamically-allocated array of crate::lightning::routing::router::RouteHintHops of arbitrary size.
+ * An event to be processed by the ChannelManager.
+ */
+typedef enum LDKMonitorEvent_Tag {
+   /**
+    * A monitor event containing an HTLCUpdate.
+    */
+   LDKMonitorEvent_HTLCEvent,
+   /**
+    * A monitor event that the Channel's commitment transaction was broadcasted.
+    */
+   LDKMonitorEvent_CommitmentTxBroadcasted,
+   /**
+    * Must be last for serialization purposes
+    */
+   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_RouteHintHopZ {
+typedef struct LDKCVec_MonitorEventZ {
    /**
     * The elements in the array.
     * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
     */
-   struct LDKRouteHintHop *data;
+   struct LDKMonitorEvent *data;
    /**
     * The number of elements pointed to by `data`.
     */
    uintptr_t datalen;
-} LDKCVec_RouteHintHopZ;
+} LDKCVec_MonitorEventZ;
 
 /**
- * The contents of CResult_RouteHintCreationErrorZ
+ * An enum which can either contain a crate::c_types::derived::C2Tuple_usizeTransactionZ or not
  */
-typedef union LDKCResult_RouteHintCreationErrorZPtr {
+typedef enum LDKCOption_C2Tuple_usizeTransactionZZ_Tag {
    /**
-    * A pointer to the contents in the success state.
-    * Reading from this pointer when `result_ok` is not set is undefined.
+    * When we're in this state, this COption_C2Tuple_usizeTransactionZZ contains a crate::c_types::derived::C2Tuple_usizeTransactionZ
     */
-   struct LDKRouteHint *result;
+   LDKCOption_C2Tuple_usizeTransactionZZ_Some,
    /**
-    * A pointer to the contents in the error state.
-    * Reading from this pointer when `result_ok` is set is undefined.
+    * When we're in this state, this COption_C2Tuple_usizeTransactionZZ contains nothing
     */
-   enum LDKCreationError *err;
-} LDKCResult_RouteHintCreationErrorZPtr;
+   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;
+
+
 
 /**
- * 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`.
+ * Information about a spendable output to a P2WSH script. See
+ * SpendableOutputDescriptor::DelayedPaymentOutput for more details on how to spend this.
  */
-typedef struct LDKCResult_RouteHintCreationErrorZ {
+typedef struct MUST_USE_STRUCT LDKDelayedPaymentOutputDescriptor {
    /**
-    * The contents of this CResult_RouteHintCreationErrorZ, 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_RouteHintCreationErrorZPtr contents;
+   LDKnativeDelayedPaymentOutputDescriptor *inner;
    /**
-    * Whether this CResult_RouteHintCreationErrorZ 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_RouteHintCreationErrorZ;
+   bool is_owned;
+} LDKDelayedPaymentOutputDescriptor;
+
+
 
 /**
- * The contents of CResult_StringErrorZ
+ * Information about a spendable output to our \"payment key\". See
+ * SpendableOutputDescriptor::StaticPaymentOutput for more details on how to spend this.
  */
-typedef union LDKCResult_StringErrorZPtr {
+typedef struct MUST_USE_STRUCT LDKStaticPaymentOutputDescriptor {
    /**
-    * 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 LDKStr *result;
+   LDKnativeStaticPaymentOutputDescriptor *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.
     */
-   enum LDKSecp256k1Error *err;
-} LDKCResult_StringErrorZPtr;
+   bool is_owned;
+} LDKStaticPaymentOutputDescriptor;
 
 /**
- * A CResult_StringErrorZ represents the result of a fallible operation,
- * containing a crate::c_types::Str on success and a crate::c_types::Secp256k1Error on failure.
- * `result_ok` indicates the overall state, and the contents are provided via `contents`.
+ * 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 LDKCResult_StringErrorZ {
+typedef enum LDKSpendableOutputDescriptor_Tag {
    /**
-    * The contents of this CResult_StringErrorZ, accessible via either
-    * `err` or `result` depending on the state of `result_ok`.
+    * 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.
     */
-   union LDKCResult_StringErrorZPtr contents;
+   LDKSpendableOutputDescriptor_StaticOutput,
    /**
-    * Whether this CResult_StringErrorZ represents a success state.
+    * 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.
     */
-   bool result_ok;
-} LDKCResult_StringErrorZ;
+   LDKSpendableOutputDescriptor_DelayedPaymentOutput,
+   /**
+    * 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.
+    */
+   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 dynamically-allocated array of crate::lightning::chain::keysinterface::SpendableOutputDescriptors of arbitrary size.
+ * This corresponds to std::vector in C++
+ */
+typedef struct LDKCVec_SpendableOutputDescriptorZ {
+   /**
+    * The elements in the array.
+    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+    */
+   struct LDKSpendableOutputDescriptor *data;
+   /**
+    * The number of elements pointed to by `data`.
+    */
+   uintptr_t datalen;
+} LDKCVec_SpendableOutputDescriptorZ;
 
 
 
 /**
- * An update generated by the underlying Channel itself which contains some new information the
- * ChannelMonitor should be made aware of.
+ * An accept_channel message to be sent or received from a peer
  */
-typedef struct MUST_USE_STRUCT LDKChannelMonitorUpdate {
+typedef struct MUST_USE_STRUCT LDKAcceptChannel {
    /**
     * 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;
+   LDKnativeAcceptChannel *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;
+} LDKAcceptChannel;
+
+
 
 /**
- * The contents of CResult_ChannelMonitorUpdateDecodeErrorZ
+ * An open_channel message to be sent or received from a peer
  */
-typedef union LDKCResult_ChannelMonitorUpdateDecodeErrorZPtr {
+typedef struct MUST_USE_STRUCT LDKOpenChannel {
    /**
-    * 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;
+   LDKnativeOpenChannel *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;
+} LDKOpenChannel;
+
+
 
 /**
- * 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`.
+ * A funding_created message to be sent or received from a peer
  */
-typedef struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ {
+typedef struct MUST_USE_STRUCT LDKFundingCreated {
    /**
-    * 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;
+   LDKnativeFundingCreated *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;
+} LDKFundingCreated;
 
 
 
 /**
- * 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.
+ * A funding_signed message to be sent or received from a peer
  */
-typedef struct MUST_USE_STRUCT LDKHTLCUpdate {
+typedef struct MUST_USE_STRUCT LDKFundingSigned {
    /**
     * 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;
+   LDKnativeFundingSigned *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;
+} LDKFundingSigned;
+
+
 
 /**
- * The contents of CResult_HTLCUpdateDecodeErrorZ
+ * A funding_locked message to be sent or received from a peer
  */
-typedef union LDKCResult_HTLCUpdateDecodeErrorZPtr {
+typedef struct MUST_USE_STRUCT LDKFundingLocked {
    /**
-    * 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 LDKHTLCUpdate *result;
+   LDKnativeFundingLocked *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_HTLCUpdateDecodeErrorZPtr;
+   bool is_owned;
+} LDKFundingLocked;
+
+
 
 /**
- * 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`.
+ * An announcement_signatures message to be sent or received from a peer
  */
-typedef struct LDKCResult_HTLCUpdateDecodeErrorZ {
+typedef struct MUST_USE_STRUCT LDKAnnouncementSignatures {
    /**
-    * The contents of this CResult_HTLCUpdateDecodeErrorZ, 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_HTLCUpdateDecodeErrorZPtr contents;
+   LDKnativeAnnouncementSignatures *inner;
    /**
-    * Whether this CResult_HTLCUpdateDecodeErrorZ 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_HTLCUpdateDecodeErrorZ;
+   bool is_owned;
+} LDKAnnouncementSignatures;
 
 
 
 /**
- * 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.
+ * 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 LDKMonitorUpdateError {
+typedef struct MUST_USE_STRUCT LDKCommitmentUpdate {
    /**
     * 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;
+   LDKnativeCommitmentUpdate *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;
+} LDKCommitmentUpdate;
+
+
 
 /**
- * The contents of CResult_NoneMonitorUpdateErrorZ
+ * A revoke_and_ack message to be sent or received from a peer
  */
-typedef union LDKCResult_NoneMonitorUpdateErrorZPtr {
+typedef struct MUST_USE_STRUCT LDKRevokeAndACK {
    /**
-    * 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;
+   LDKnativeRevokeAndACK *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;
+} LDKRevokeAndACK;
 
-/**
- * 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 {
-   /**
-    * The contents of this CResult_NoneMonitorUpdateErrorZ, accessible via either
-    * `err` or `result` depending on the state of `result_ok`.
-    */
-   union LDKCResult_NoneMonitorUpdateErrorZPtr contents;
-   /**
-    * Whether this CResult_NoneMonitorUpdateErrorZ represents a success state.
-    */
-   bool result_ok;
-} LDKCResult_NoneMonitorUpdateErrorZ;
 
-/**
- * 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;
-   /**
-    * The element at position 1
-    */
-   struct LDKCVec_u8Z b;
-} LDKC2Tuple_OutPointScriptZ;
 
 /**
- * A tuple of 2 elements. See the individual fields for the types contained.
+ * A closing_signed message to be sent or received from a peer
  */
-typedef struct LDKC2Tuple_u32ScriptZ {
+typedef struct MUST_USE_STRUCT LDKClosingSigned {
    /**
-    * The element at position 0
+    * 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.
     */
-   uint32_t a;
+   LDKnativeClosingSigned *inner;
    /**
-    * The element at position 1
+    * 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 b;
-} LDKC2Tuple_u32ScriptZ;
+   bool is_owned;
+} LDKClosingSigned;
+
 
-/**
- * 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;
 
 /**
- * A tuple of 2 elements. See the individual fields for the types contained.
+ * A shutdown message to be sent or received from a peer
  */
-typedef struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ {
+typedef struct MUST_USE_STRUCT LDKShutdown {
    /**
-    * The element at position 0
+    * 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 LDKThirtyTwoBytes a;
+   LDKnativeShutdown *inner;
    /**
-    * The element at position 1
+    * 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_C2Tuple_u32ScriptZZ b;
-} LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ;
+   bool is_owned;
+} LDKShutdown;
+
+
 
 /**
- * A dynamically-allocated array of crate::c_types::derived::C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZs of arbitrary size.
- * This corresponds to std::vector in C++
+ * A channel_reestablish message to be sent or received from a peer
  */
-typedef struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ {
+typedef struct MUST_USE_STRUCT LDKChannelReestablish {
    /**
-    * 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_u32ScriptZZZ *data;
+   LDKnativeChannelReestablish *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_TxidCVec_C2Tuple_u32ScriptZZZZ;
+   bool is_owned;
+} LDKChannelReestablish;
+
+
 
 /**
- * An event to be processed by the ChannelManager.
+ * A channel_announcement message to be sent or received from a peer
  */
-typedef enum LDKMonitorEvent_Tag {
-   /**
-    * A monitor event containing an HTLCUpdate.
-    */
-   LDKMonitorEvent_HTLCEvent,
+typedef struct MUST_USE_STRUCT LDKChannelAnnouncement {
    /**
-    * A monitor event that the Channel's commitment transaction was broadcasted.
+    * 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.
     */
-   LDKMonitorEvent_CommitmentTxBroadcasted,
+   LDKnativeChannelAnnouncement *inner;
    /**
-    * Must be last for serialization purposes
+    * 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.
     */
-   LDKMonitorEvent_Sentinel,
-} LDKMonitorEvent_Tag;
+   bool is_owned;
+} LDKChannelAnnouncement;
+
 
-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++
+ * A channel_update message to be sent or received from a peer
  */
-typedef struct LDKCVec_MonitorEventZ {
+typedef struct MUST_USE_STRUCT LDKChannelUpdate {
    /**
-    * 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 LDKMonitorEvent *data;
+   LDKnativeChannelUpdate *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_MonitorEventZ;
+   bool is_owned;
+} LDKChannelUpdate;
 
 
 
 /**
- * Information about a spendable output to a P2WSH script. See
- * SpendableOutputDescriptor::DelayedPaymentOutput for more details on how to spend this.
+ * A node_announcement message to be sent or received from a peer
  */
-typedef struct MUST_USE_STRUCT LDKDelayedPaymentOutputDescriptor {
+typedef struct MUST_USE_STRUCT LDKNodeAnnouncement {
    /**
     * 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;
+   LDKnativeNodeAnnouncement *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;
+} LDKNodeAnnouncement;
 
 
 
 /**
- * Information about a spendable output to our \"payment key\". See
- * SpendableOutputDescriptor::StaticPaymentOutput for more details on how to spend this.
+ * An error message to be sent or received from a peer
  */
-typedef struct MUST_USE_STRUCT LDKStaticPaymentOutputDescriptor {
+typedef struct MUST_USE_STRUCT LDKErrorMessage {
    /**
     * 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;
+   LDKnativeErrorMessage *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;
+} LDKErrorMessage;
 
 /**
- * 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.
+ * Used to put an error message in a LightningError
  */
-typedef enum LDKSpendableOutputDescriptor_Tag {
+typedef enum LDKErrorAction_Tag {
    /**
-    * 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 peer took some action which made us think they were useless. Disconnect them.
     */
-   LDKSpendableOutputDescriptor_StaticOutput,
+   LDKErrorAction_DisconnectPeer,
    /**
-    * 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 peer did something harmless that we weren't able to process, just log and ignore
     */
-   LDKSpendableOutputDescriptor_DelayedPaymentOutput,
+   LDKErrorAction_IgnoreError,
    /**
-    * 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 peer did something incorrect. Tell them.
     */
-   LDKSpendableOutputDescriptor_StaticPaymentOutput,
+   LDKErrorAction_SendErrorMessage,
    /**
     * Must be last for serialization purposes
     */
-   LDKSpendableOutputDescriptor_Sentinel,
-} LDKSpendableOutputDescriptor_Tag;
+   LDKErrorAction_Sentinel,
+} LDKErrorAction_Tag;
 
-typedef struct LDKSpendableOutputDescriptor_LDKStaticOutput_Body {
+typedef struct LDKErrorAction_LDKDisconnectPeer_Body {
    /**
-    * The outpoint which is spendable
+    * An error message which we should make an effort to send before we disconnect.
     */
-   struct LDKOutPoint outpoint;
+   struct LDKErrorMessage msg;
+} LDKErrorAction_LDKDisconnectPeer_Body;
+
+typedef struct LDKErrorAction_LDKSendErrorMessage_Body {
    /**
-    * The output which is referenced by the given outpoint.
+    * The message to send.
     */
-   struct LDKTxOut output;
-} LDKSpendableOutputDescriptor_LDKStaticOutput_Body;
+   struct LDKErrorMessage msg;
+} LDKErrorAction_LDKSendErrorMessage_Body;
 
-typedef struct MUST_USE_STRUCT LDKSpendableOutputDescriptor {
-   LDKSpendableOutputDescriptor_Tag tag;
+typedef struct MUST_USE_STRUCT LDKErrorAction {
+   LDKErrorAction_Tag tag;
    union {
-      LDKSpendableOutputDescriptor_LDKStaticOutput_Body static_output;
-      struct {
-         struct LDKDelayedPaymentOutputDescriptor delayed_payment_output;
-      };
-      struct {
-         struct LDKStaticPaymentOutputDescriptor static_payment_output;
-      };
+      LDKErrorAction_LDKDisconnectPeer_Body disconnect_peer;
+      LDKErrorAction_LDKSendErrorMessage_Body send_error_message;
    };
-} LDKSpendableOutputDescriptor;
+} LDKErrorAction;
 
 /**
- * A dynamically-allocated array of crate::lightning::chain::keysinterface::SpendableOutputDescriptors of arbitrary size.
- * This corresponds to std::vector in C++
+ * 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 LDKCVec_SpendableOutputDescriptorZ {
+typedef enum LDKHTLCFailChannelUpdate_Tag {
    /**
-    * The elements in the array.
-    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+    * We received an error which included a full ChannelUpdate message.
     */
-   struct LDKSpendableOutputDescriptor *data;
+   LDKHTLCFailChannelUpdate_ChannelUpdateMessage,
    /**
-    * The number of elements pointed to by `data`.
+    * We received an error which indicated only that a channel has been closed
     */
-   uintptr_t datalen;
-} LDKCVec_SpendableOutputDescriptorZ;
+   LDKHTLCFailChannelUpdate_ChannelClosed,
+   /**
+    * We received an error which indicated only that a node has failed
+    */
+   LDKHTLCFailChannelUpdate_NodeFailure,
+   /**
+    * Must be last for serialization purposes
+    */
+   LDKHTLCFailChannelUpdate_Sentinel,
+} LDKHTLCFailChannelUpdate_Tag;
 
-/**
- * An Event which you should probably take some action in response to.
- *
- * Note that while Writeable and Readable are implemented for Event, you probably shouldn't use
- * them directly as they don't round-trip exactly (for example FundingGenerationReady is never
- * written as it makes no sense to respond to it after reconnecting to peers).
- */
-typedef enum LDKEvent_Tag {
+typedef struct LDKHTLCFailChannelUpdate_LDKChannelUpdateMessage_Body {
    /**
-    * 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!
+    * The unwrapped message we received
     */
-   LDKEvent_FundingGenerationReady,
+   struct LDKChannelUpdate msg;
+} LDKHTLCFailChannelUpdate_LDKChannelUpdateMessage_Body;
+
+typedef struct LDKHTLCFailChannelUpdate_LDKChannelClosed_Body {
    /**
-    * 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.
+    * The short_channel_id which has now closed.
     */
-   LDKEvent_PaymentReceived,
+   uint64_t short_channel_id;
    /**
-    * 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).
+    * when this true, this channel should be permanently removed from the
+    * consideration. Otherwise, this channel can be restored as new channel_update is received
     */
-   LDKEvent_PaymentSent,
+   bool is_permanent;
+} LDKHTLCFailChannelUpdate_LDKChannelClosed_Body;
+
+typedef struct LDKHTLCFailChannelUpdate_LDKNodeFailure_Body {
    /**
-    * Indicates an outbound payment we made failed. Probably some intermediary node dropped
-    * something. You may wish to retry with a different route.
+    * The node_id that has failed.
     */
-   LDKEvent_PaymentFailed,
+   struct LDKPublicKey node_id;
    /**
-    * Used to indicate that ChannelManager::process_pending_htlc_forwards should be called at a
-    * time in the future.
+    * 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
     */
-   LDKEvent_PendingHTLCsForwardable,
+   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 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 MUST_USE_STRUCT LDKQueryChannelRange {
    /**
-    * 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.
+    * 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.
     */
-   LDKEvent_SpendableOutputs,
+   LDKnativeQueryChannelRange *inner;
    /**
-    * Must be last for serialization purposes
+    * 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.
     */
-   LDKEvent_Sentinel,
-} LDKEvent_Tag;
+   bool is_owned;
+} LDKQueryChannelRange;
 
-typedef struct LDKEvent_LDKFundingGenerationReady_Body {
+
+
+/**
+ * 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 MUST_USE_STRUCT LDKQueryShortChannelIds {
    /**
-    * The random channel_id we picked which you'll need to pass into
-    * ChannelManager::funding_transaction_generated.
+    * 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 LDKThirtyTwoBytes temporary_channel_id;
+   LDKnativeQueryShortChannelIds *inner;
    /**
-    * The value, in satoshis, that the output should have.
+    * 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 channel_value_satoshis;
+   bool is_owned;
+} LDKQueryShortChannelIds;
+
+
+
+/**
+ * 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 LDKReplyChannelRange {
    /**
-    * 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;
+   LDKnativeReplyChannelRange *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;
+} LDKReplyChannelRange;
 
-typedef struct LDKEvent_LDKPaymentReceived_Body {
+/**
+ * An event generated by ChannelManager which indicates a message should be sent to a peer (or
+ * broadcast to most peers).
+ * These events are handled by PeerManager::process_events if you are using a PeerManager.
+ */
+typedef enum LDKMessageSendEvent_Tag {
    /**
-    * The hash for which the preimage should be handed to the ChannelManager.
+    * Used to indicate that we've accepted a channel open and should send the accept_channel
+    * message provided to the given peer.
     */
-   struct LDKThirtyTwoBytes payment_hash;
+   LDKMessageSendEvent_SendAcceptChannel,
    /**
-    * 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
+    * Used to indicate that we've initiated a channel open and should send the open_channel
+    * message provided to the given peer.
     */
-   struct LDKThirtyTwoBytes payment_preimage;
+   LDKMessageSendEvent_SendOpenChannel,
    /**
-    * 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
+    * Used to indicate that a funding_created message should be sent to the peer with the given node_id.
     */
-   struct LDKThirtyTwoBytes payment_secret;
+   LDKMessageSendEvent_SendFundingCreated,
    /**
-    * 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!).
+    * Used to indicate that a funding_signed message should be sent to the peer with the given node_id.
     */
-   uint64_t amt;
+   LDKMessageSendEvent_SendFundingSigned,
    /**
-    * 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.
+    * Used to indicate that a funding_locked message should be sent to the peer with the given node_id.
+    */
+   LDKMessageSendEvent_SendFundingLocked,
+   /**
+    * Used to indicate that an announcement_signatures message should be sent to the peer with the given node_id.
+    */
+   LDKMessageSendEvent_SendAnnouncementSignatures,
+   /**
+    * Used to indicate that a series of HTLC update messages, as well as a commitment_signed
+    * message should be sent to the peer with the given node_id.
+    */
+   LDKMessageSendEvent_UpdateHTLCs,
+   /**
+    * Used to indicate that a revoke_and_ack message should be sent to the peer with the given node_id.
+    */
+   LDKMessageSendEvent_SendRevokeAndACK,
+   /**
+    * Used to indicate that a closing_signed message should be sent to the peer with the given node_id.
+    */
+   LDKMessageSendEvent_SendClosingSigned,
+   /**
+    * Used to indicate that a shutdown message should be sent to the peer with the given node_id.
+    */
+   LDKMessageSendEvent_SendShutdown,
+   /**
+    * Used to indicate that a channel_reestablish message should be sent to the peer with the given node_id.
+    */
+   LDKMessageSendEvent_SendChannelReestablish,
+   /**
+    * Used to indicate that a channel_announcement and channel_update should be broadcast to all
+    * peers (except the peer with node_id either msg.contents.node_id_1 or msg.contents.node_id_2).
     *
-    * [`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
+    * Note that after doing so, you very likely (unless you did so very recently) want to call
+    * ChannelManager::broadcast_node_announcement to trigger a BroadcastNodeAnnouncement event.
+    * This ensures that any nodes which see our channel_announcement also have a relevant
+    * node_announcement, including relevant feature flags which may be important for routing
+    * through or to us.
+    */
+   LDKMessageSendEvent_BroadcastChannelAnnouncement,
+   /**
+    * Used to indicate that a node_announcement should be broadcast to all peers.
+    */
+   LDKMessageSendEvent_BroadcastNodeAnnouncement,
+   /**
+    * Used to indicate that a channel_update should be broadcast to all peers.
+    */
+   LDKMessageSendEvent_BroadcastChannelUpdate,
+   /**
+    * Broadcast an error downstream to be handled
+    */
+   LDKMessageSendEvent_HandleError,
+   /**
+    * When a payment fails we may receive updates back from the hop where it failed. In such
+    * cases this event is generated so that we can inform the network graph of this information.
+    */
+   LDKMessageSendEvent_PaymentFailureNetworkUpdate,
+   /**
+    * Query a peer for channels with funding transaction UTXOs in a block range.
+    */
+   LDKMessageSendEvent_SendChannelRangeQuery,
+   /**
+    * Request routing gossip messages from a peer for a list of channels identified by
+    * their short_channel_ids.
+    */
+   LDKMessageSendEvent_SendShortIdsQuery,
+   /**
+    * Sends a reply to a channel range query. This may be one of several SendReplyChannelRange events
+    * emitted during processing of the query.
     */
-   uint64_t user_payment_id;
-} LDKEvent_LDKPaymentReceived_Body;
-
-typedef struct LDKEvent_LDKPaymentSent_Body {
+   LDKMessageSendEvent_SendReplyChannelRange,
    /**
-    * 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!
+    * Must be last for serialization purposes
     */
-   struct LDKThirtyTwoBytes payment_preimage;
-} LDKEvent_LDKPaymentSent_Body;
+   LDKMessageSendEvent_Sentinel,
+} LDKMessageSendEvent_Tag;
 
-typedef struct LDKEvent_LDKPaymentFailed_Body {
+typedef struct LDKMessageSendEvent_LDKSendAcceptChannel_Body {
    /**
-    * The hash which was given to ChannelManager::send_payment.
+    * The node_id of the node which should receive this message
     */
-   struct LDKThirtyTwoBytes payment_hash;
+   struct LDKPublicKey node_id;
    /**
-    * 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.
+    * The message which should be sent.
     */
-   bool rejected_by_dest;
-} LDKEvent_LDKPaymentFailed_Body;
+   struct LDKAcceptChannel msg;
+} LDKMessageSendEvent_LDKSendAcceptChannel_Body;
 
-typedef struct LDKEvent_LDKPendingHTLCsForwardable_Body {
+typedef struct LDKMessageSendEvent_LDKSendOpenChannel_Body {
    /**
-    * 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 node_id of the node which should receive this message
     */
-   uint64_t time_forwardable;
-} LDKEvent_LDKPendingHTLCsForwardable_Body;
-
-typedef struct LDKEvent_LDKSpendableOutputs_Body {
+   struct LDKPublicKey node_id;
    /**
-    * The outputs which you should store as spendable by you.
+    * The message which should be sent.
     */
-   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;
+   struct LDKOpenChannel msg;
+} LDKMessageSendEvent_LDKSendOpenChannel_Body;
 
-/**
- * A dynamically-allocated array of crate::lightning::util::events::Events of arbitrary size.
- * This corresponds to std::vector in C++
- */
-typedef struct LDKCVec_EventZ {
+typedef struct LDKMessageSendEvent_LDKSendFundingCreated_Body {
    /**
-    * The elements in the array.
-    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+    * The node_id of the node which should receive this message
     */
-   struct LDKEvent *data;
+   struct LDKPublicKey node_id;
    /**
-    * The number of elements pointed to by `data`.
+    * The message which should be sent.
     */
-   uintptr_t datalen;
-} LDKCVec_EventZ;
+   struct LDKFundingCreated msg;
+} LDKMessageSendEvent_LDKSendFundingCreated_Body;
 
-/**
- * A dynamically-allocated array of crate::c_types::Transactions of arbitrary size.
- * This corresponds to std::vector in C++
- */
-typedef struct LDKCVec_TransactionZ {
+typedef struct LDKMessageSendEvent_LDKSendFundingSigned_Body {
    /**
-    * The elements in the array.
-    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+    * The node_id of the node which should receive this message
     */
-   struct LDKTransaction *data;
+   struct LDKPublicKey node_id;
    /**
-    * The number of elements pointed to by `data`.
+    * The message which should be sent.
     */
-   uintptr_t datalen;
-} LDKCVec_TransactionZ;
+   struct LDKFundingSigned msg;
+} LDKMessageSendEvent_LDKSendFundingSigned_Body;
 
-/**
- * A tuple of 2 elements. See the individual fields for the types contained.
- */
-typedef struct LDKC2Tuple_usizeTransactionZ {
+typedef struct LDKMessageSendEvent_LDKSendFundingLocked_Body {
    /**
-    * The element at position 0
+    * The node_id of the node which should receive these message(s)
     */
-   uintptr_t a;
+   struct LDKPublicKey node_id;
    /**
-    * The element at position 1
+    * The funding_locked message which should be sent.
     */
-   struct LDKTransaction b;
-} LDKC2Tuple_usizeTransactionZ;
+   struct LDKFundingLocked msg;
+} LDKMessageSendEvent_LDKSendFundingLocked_Body;
 
-/**
- * A dynamically-allocated array of crate::c_types::derived::C2Tuple_usizeTransactionZs of arbitrary size.
- * This corresponds to std::vector in C++
- */
-typedef struct LDKCVec_C2Tuple_usizeTransactionZZ {
+typedef struct LDKMessageSendEvent_LDKSendAnnouncementSignatures_Body {
    /**
-    * The elements in the array.
-    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+    * The node_id of the node which should receive these message(s)
     */
-   struct LDKC2Tuple_usizeTransactionZ *data;
+   struct LDKPublicKey node_id;
    /**
-    * The number of elements pointed to by `data`.
+    * The announcement_signatures message which should be sent.
     */
-   uintptr_t datalen;
-} LDKCVec_C2Tuple_usizeTransactionZZ;
+   struct LDKAnnouncementSignatures msg;
+} LDKMessageSendEvent_LDKSendAnnouncementSignatures_Body;
 
-/**
- * A tuple of 2 elements. See the individual fields for the types contained.
- */
-typedef struct LDKC2Tuple_u32TxOutZ {
+typedef struct LDKMessageSendEvent_LDKUpdateHTLCs_Body {
    /**
-    * The element at position 0
+    * The node_id of the node which should receive these message(s)
     */
-   uint32_t a;
+   struct LDKPublicKey node_id;
    /**
-    * The element at position 1
+    * The update messages which should be sent. ALL messages in the struct should be sent!
     */
-   struct LDKTxOut b;
-} LDKC2Tuple_u32TxOutZ;
+   struct LDKCommitmentUpdate updates;
+} LDKMessageSendEvent_LDKUpdateHTLCs_Body;
 
-/**
- * A dynamically-allocated array of crate::c_types::derived::C2Tuple_u32TxOutZs of arbitrary size.
- * This corresponds to std::vector in C++
- */
-typedef struct LDKCVec_C2Tuple_u32TxOutZZ {
+typedef struct LDKMessageSendEvent_LDKSendRevokeAndACK_Body {
    /**
-    * The elements in the array.
-    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+    * The node_id of the node which should receive this message
     */
-   struct LDKC2Tuple_u32TxOutZ *data;
+   struct LDKPublicKey node_id;
    /**
-    * The number of elements pointed to by `data`.
+    * The message which should be sent.
     */
-   uintptr_t datalen;
-} LDKCVec_C2Tuple_u32TxOutZZ;
+   struct LDKRevokeAndACK msg;
+} LDKMessageSendEvent_LDKSendRevokeAndACK_Body;
 
-/**
- * A tuple of 2 elements. See the individual fields for the types contained.
- */
-typedef struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ {
+typedef struct LDKMessageSendEvent_LDKSendClosingSigned_Body {
    /**
-    * The element at position 0
+    * The node_id of the node which should receive this message
     */
-   struct LDKThirtyTwoBytes a;
+   struct LDKPublicKey node_id;
    /**
-    * The element at position 1
+    * The message which should be sent.
     */
-   struct LDKCVec_C2Tuple_u32TxOutZZ b;
-} LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ;
+   struct LDKClosingSigned msg;
+} LDKMessageSendEvent_LDKSendClosingSigned_Body;
 
-/**
- * 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 LDKCVec_TransactionOutputsZ {
+typedef struct LDKMessageSendEvent_LDKSendShutdown_Body {
    /**
-    * The elements in the array.
-    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+    * The node_id of the node which should receive this message
     */
-   struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *data;
+   struct LDKPublicKey node_id;
    /**
-    * The number of elements pointed to by `data`.
+    * The message which should be sent.
     */
-   uintptr_t datalen;
-} LDKCVec_TransactionOutputsZ;
+   struct LDKShutdown msg;
+} LDKMessageSendEvent_LDKSendShutdown_Body;
 
-/**
- * A dynamically-allocated array of crate::c_types::ThirtyTwoBytess of arbitrary size.
- * This corresponds to std::vector in C++
- */
-typedef struct LDKCVec_TxidZ {
+typedef struct LDKMessageSendEvent_LDKSendChannelReestablish_Body {
    /**
-    * The elements in the array.
-    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+    * The node_id of the node which should receive this message
     */
-   struct LDKThirtyTwoBytes *data;
+   struct LDKPublicKey node_id;
    /**
-    * The number of elements pointed to by `data`.
+    * The message which should be sent.
     */
-   uintptr_t datalen;
-} LDKCVec_TxidZ;
+   struct LDKChannelReestablish msg;
+} LDKMessageSendEvent_LDKSendChannelReestablish_Body;
 
-/**
- * The contents of CResult_NoneChannelMonitorUpdateErrZ
- */
-typedef union LDKCResult_NoneChannelMonitorUpdateErrZPtr {
+typedef struct LDKMessageSendEvent_LDKBroadcastChannelAnnouncement_Body {
    /**
-    * Note that this value is always NULL, as there are no contents in the OK variant
+    * The channel_announcement which should be sent.
     */
-   void *result;
+   struct LDKChannelAnnouncement msg;
    /**
-    * A pointer to the contents in the error state.
-    * Reading from this pointer when `result_ok` is set is undefined.
+    * The followup channel_update which should be sent.
     */
-   enum LDKChannelMonitorUpdateErr *err;
-} LDKCResult_NoneChannelMonitorUpdateErrZPtr;
+   struct LDKChannelUpdate update_msg;
+} LDKMessageSendEvent_LDKBroadcastChannelAnnouncement_Body;
 
-/**
- * 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 LDKCResult_NoneChannelMonitorUpdateErrZ {
+typedef struct LDKMessageSendEvent_LDKBroadcastNodeAnnouncement_Body {
    /**
-    * The contents of this CResult_NoneChannelMonitorUpdateErrZ, accessible via either
-    * `err` or `result` depending on the state of `result_ok`.
+    * The node_announcement which should be sent.
     */
-   union LDKCResult_NoneChannelMonitorUpdateErrZPtr contents;
+   struct LDKNodeAnnouncement msg;
+} LDKMessageSendEvent_LDKBroadcastNodeAnnouncement_Body;
+
+typedef struct LDKMessageSendEvent_LDKBroadcastChannelUpdate_Body {
    /**
-    * Whether this CResult_NoneChannelMonitorUpdateErrZ represents a success state.
+    * The channel_update which should be sent.
     */
-   bool result_ok;
-} LDKCResult_NoneChannelMonitorUpdateErrZ;
+   struct LDKChannelUpdate msg;
+} LDKMessageSendEvent_LDKBroadcastChannelUpdate_Body;
 
-/**
- * A tuple of 2 elements. See the individual fields for the types contained.
- */
-typedef struct LDKC2Tuple_SignatureCVec_SignatureZZ {
+typedef struct LDKMessageSendEvent_LDKHandleError_Body {
    /**
-    * The element at position 0
+    * The node_id of the node which should receive this message
     */
-   struct LDKSignature a;
+   struct LDKPublicKey node_id;
+   /**
+    * The action which should be taken.
+    */
+   struct LDKErrorAction action;
+} LDKMessageSendEvent_LDKHandleError_Body;
+
+typedef struct LDKMessageSendEvent_LDKPaymentFailureNetworkUpdate_Body {
    /**
-    * The element at position 1
+    * The channel/node update which should be sent to NetGraphMsgHandler
     */
-   struct LDKCVec_SignatureZ b;
-} LDKC2Tuple_SignatureCVec_SignatureZZ;
+   struct LDKHTLCFailChannelUpdate update;
+} LDKMessageSendEvent_LDKPaymentFailureNetworkUpdate_Body;
 
-/**
- * The contents of CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ
- */
-typedef union LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZPtr {
+typedef struct LDKMessageSendEvent_LDKSendChannelRangeQuery_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 this message recipient
     */
-   struct LDKC2Tuple_SignatureCVec_SignatureZZ *result;
+   struct LDKPublicKey node_id;
    /**
-    * Note that this value is always NULL, as there are no contents in the Err variant
+    * The query_channel_range which should be sent.
     */
-   void *err;
-} LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZPtr;
+   struct LDKQueryChannelRange msg;
+} LDKMessageSendEvent_LDKSendChannelRangeQuery_Body;
 
-/**
- * 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 {
+typedef struct LDKMessageSendEvent_LDKSendShortIdsQuery_Body {
    /**
-    * The contents of this CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ, accessible via either
-    * `err` or `result` depending on the state of `result_ok`.
+    * The node_id of this message recipient
     */
-   union LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZPtr contents;
+   struct LDKPublicKey node_id;
    /**
-    * Whether this CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ represents a success state.
+    * The query_short_channel_ids which should be sent.
     */
-   bool result_ok;
-} LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ;
+   struct LDKQueryShortChannelIds msg;
+} LDKMessageSendEvent_LDKSendShortIdsQuery_Body;
 
-/**
- * The contents of CResult_SignatureNoneZ
- */
-typedef union LDKCResult_SignatureNoneZPtr {
+typedef struct LDKMessageSendEvent_LDKSendReplyChannelRange_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 this message recipient
     */
-   struct LDKSignature *result;
+   struct LDKPublicKey node_id;
    /**
-    * Note that this value is always NULL, as there are no contents in the Err variant
+    * The reply_channel_range which should be sent.
     */
-   void *err;
-} LDKCResult_SignatureNoneZPtr;
+   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 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`.
+ * A dynamically-allocated array of crate::lightning::util::events::MessageSendEvents of arbitrary size.
+ * This corresponds to std::vector in C++
  */
-typedef struct LDKCResult_SignatureNoneZ {
+typedef struct LDKCVec_MessageSendEventZ {
    /**
-    * The contents of this CResult_SignatureNoneZ, 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_SignatureNoneZPtr contents;
+   struct LDKMessageSendEvent *data;
    /**
-    * Whether this CResult_SignatureNoneZ represents a success state.
+    * The number of elements pointed to by `data`.
     */
-   bool result_ok;
-} LDKCResult_SignatureNoneZ;
+   uintptr_t datalen;
+} LDKCVec_MessageSendEventZ;
 
 
 
 /**
- * The unsigned part of a channel_announcement
+ * Features used within an `init` message.
  */
-typedef struct MUST_USE_STRUCT LDKUnsignedChannelAnnouncement {
+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.
     */
-   LDKnativeUnsignedChannelAnnouncement *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;
-} LDKUnsignedChannelAnnouncement;
+} LDKInitFeatures;
 
 /**
- * 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_InitFeaturesDecodeErrorZ
  */
-typedef struct LDKBaseSign {
-   /**
-    * 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 the per-commitment point for a specific commitment number
-    *
-    * Note that the commitment number starts at (1 << 48) - 1 and counts backwards.
-    */
-   struct LDKPublicKey (*get_per_commitment_point)(const void *this_arg, uint64_t idx);
-   /**
-    * Gets the commitment secret for a specific commitment number as part of the revocation process
-    *
-    * An external signer implementation should error here if the commitment was already signed
-    * and should refuse to sign it in the future.
-    *
-    * May be called more than once for the same index.
-    *
-    * Note that the commitment number starts at (1 << 48) - 1 and counts backwards.
-    */
-   struct LDKThirtyTwoBytes (*release_commitment_secret)(const void *this_arg, uint64_t idx);
-   /**
-    * Gets the holder's channel public keys and basepoints
-    */
-   struct LDKChannelPublicKeys pubkeys;
-   /**
-    * Fill in the pubkeys field as a reference to it will be given to Rust after this returns
-    * Note that this takes a pointer to this object, not the this_ptr like other methods do
-    * This function pointer may be NULL if pubkeys is filled in when this object is created and never needs updating.
-    */
-   void (*set_pubkeys)(const struct LDKBaseSign*NONNULL_PTR );
-   /**
-    * 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 LDKThirtyTwoBytes (*channel_keys_id)(const void *this_arg);
+typedef union LDKCResult_InitFeaturesDecodeErrorZPtr {
    /**
-    * 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.
+    * A pointer to the contents in the success state.
+    * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ (*sign_counterparty_commitment)(const void *this_arg, const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx);
+   struct LDKInitFeatures *result;
    /**
-    * 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.
+    * A pointer to the contents in the error state.
+    * Reading from this pointer when `result_ok` is set is undefined.
     */
-   struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ (*sign_holder_commitment_and_htlcs)(const void *this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx);
+   struct LDKDecodeError *err;
+} LDKCResult_InitFeaturesDecodeErrorZPtr;
+
+/**
+ * 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_InitFeaturesDecodeErrorZ {
    /**
-    * Create a signature for the given input in a transaction spending an HTLC transaction output
-    * or a commitment transaction `to_local` output when our counterparty broadcasts an old state.
-    *
-    * A justice transaction may claim multiple 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 multiple times 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).
+    * The contents of this CResult_InitFeaturesDecodeErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   struct LDKCResult_SignatureNoneZ (*sign_justice_revoked_output)(const void *this_arg, struct LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (*per_commitment_key)[32]);
+   union LDKCResult_InitFeaturesDecodeErrorZPtr contents;
    /**
-    * Create a signature for the given input in a transaction spending a commitment transaction
-    * HTLC output when our counterparty broadcasts an old state.
-    *
-    * A justice transaction may claim multiple 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 multiple times 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), thus changing the format of the witness script
-    * (which is committed to in the BIP 143 signatures).
+    * Whether this CResult_InitFeaturesDecodeErrorZ represents a success state.
     */
-   struct LDKCResult_SignatureNoneZ (*sign_justice_revoked_htlc)(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);
-   /**
-    * 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.
+   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.
     */
-   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);
+   LDKnativeNodeFeatures *inner;
    /**
-    * 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.
+    * 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 LDKCResult_SignatureNoneZ (*sign_closing_transaction)(const void *this_arg, struct LDKTransaction closing_tx);
+   bool is_owned;
+} LDKNodeFeatures;
+
+/**
+ * The contents of CResult_NodeFeaturesDecodeErrorZ
+ */
+typedef union LDKCResult_NodeFeaturesDecodeErrorZPtr {
    /**
-    * 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.
+    * A pointer to the contents in the success state.
+    * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKCResult_SignatureNoneZ (*sign_channel_announcement)(const void *this_arg, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg);
+   struct LDKNodeFeatures *result;
    /**
-    * 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.
+    * A pointer to the contents in the error state.
+    * Reading from this pointer when `result_ok` is set is undefined.
     */
-   void (*ready_channel)(void *this_arg, const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters);
+   struct LDKDecodeError *err;
+} LDKCResult_NodeFeaturesDecodeErrorZPtr;
+
+/**
+ * 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_NodeFeaturesDecodeErrorZ {
    /**
-    * 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 contents of this CResult_NodeFeaturesDecodeErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   void (*free)(void *this_arg);
-} LDKBaseSign;
+   union LDKCResult_NodeFeaturesDecodeErrorZPtr contents;
+   /**
+    * Whether this CResult_NodeFeaturesDecodeErrorZ represents a success state.
+    */
+   bool result_ok;
+} LDKCResult_NodeFeaturesDecodeErrorZ;
+
+
 
 /**
- * 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.
+ * Features used within a `channel_announcement` message.
  */
-typedef struct LDKSign {
+typedef struct MUST_USE_STRUCT LDKChannelFeatures {
    /**
-    * 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 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 *this_arg;
+   LDKnativeChannelFeatures *inner;
    /**
-    * Implementation of BaseSign for this object.
+    * 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 LDKBaseSign BaseSign;
+   bool is_owned;
+} LDKChannelFeatures;
+
+/**
+ * The contents of CResult_ChannelFeaturesDecodeErrorZ
+ */
+typedef union LDKCResult_ChannelFeaturesDecodeErrorZPtr {
    /**
-    * 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 pointer to the contents in the success state.
+    * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKBaseSign (*BaseSign_clone)(const struct LDKBaseSign *NONNULL_PTR orig_BaseSign);
+   struct LDKChannelFeatures *result;
    /**
-    * Serialize the object into a byte array
+    * A pointer to the contents in the error state.
+    * Reading from this pointer when `result_ok` is set is undefined.
     */
-   struct LDKCVec_u8Z (*write)(const void *this_arg);
+   struct LDKDecodeError *err;
+} LDKCResult_ChannelFeaturesDecodeErrorZPtr;
+
+/**
+ * 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_ChannelFeaturesDecodeErrorZ {
    /**
-    * 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 contents of this CResult_ChannelFeaturesDecodeErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   void *(*clone)(const void *this_arg);
+   union LDKCResult_ChannelFeaturesDecodeErrorZPtr 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_ChannelFeaturesDecodeErrorZ represents a success state.
     */
-   void (*free)(void *this_arg);
-} LDKSign;
+   bool result_ok;
+} LDKCResult_ChannelFeaturesDecodeErrorZ;
 
 
 
 /**
- * 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!
+ * Features used within an invoice.
  */
-typedef struct MUST_USE_STRUCT LDKChannelMonitor {
+typedef struct MUST_USE_STRUCT LDKInvoiceFeatures {
    /**
     * 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;
+   LDKnativeInvoiceFeatures *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;
+} LDKInvoiceFeatures;
 
 /**
- * A tuple of 2 elements. See the individual fields for the types contained.
+ * The contents of CResult_InvoiceFeaturesDecodeErrorZ
  */
-typedef struct LDKC2Tuple_BlockHashChannelMonitorZ {
+typedef union LDKCResult_InvoiceFeaturesDecodeErrorZPtr {
    /**
-    * 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 LDKThirtyTwoBytes a;
+   struct LDKInvoiceFeatures *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 LDKChannelMonitor b;
-} LDKC2Tuple_BlockHashChannelMonitorZ;
+   struct LDKDecodeError *err;
+} LDKCResult_InvoiceFeaturesDecodeErrorZPtr;
 
 /**
- * The contents of CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ
+ * 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 union LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZPtr {
+typedef struct LDKCResult_InvoiceFeaturesDecodeErrorZ {
+   /**
+    * The contents of this CResult_InvoiceFeaturesDecodeErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
+    */
+   union LDKCResult_InvoiceFeaturesDecodeErrorZPtr contents;
+   /**
+    * Whether this CResult_InvoiceFeaturesDecodeErrorZ represents a success state.
+    */
+   bool result_ok;
+} LDKCResult_InvoiceFeaturesDecodeErrorZ;
+
+/**
+ * The contents of CResult_DelayedPaymentOutputDescriptorDecodeErrorZ
+ */
+typedef union LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZPtr {
    /**
     * 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;
+   struct LDKDelayedPaymentOutputDescriptor *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;
+} LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZPtr;
 
 /**
- * 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.
+ * A CResult_DelayedPaymentOutputDescriptorDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::chain::keysinterface::DelayedPaymentOutputDescriptor 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 {
+typedef struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ {
    /**
-    * The contents of this CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ, accessible via either
+    * The contents of this CResult_DelayedPaymentOutputDescriptorDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZPtr contents;
+   union LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ represents a success state.
+    * Whether this CResult_DelayedPaymentOutputDescriptorDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ;
-
+} LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ;
 
+/**
+ * The contents of CResult_StaticPaymentOutputDescriptorDecodeErrorZ
+ */
+typedef union LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZPtr {
+   /**
+    * A pointer to the contents in the success state.
+    * Reading from this pointer when `result_ok` is not set is undefined.
+    */
+   struct LDKStaticPaymentOutputDescriptor *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_StaticPaymentOutputDescriptorDecodeErrorZPtr;
 
 /**
- * A hop in a route
+ * A CResult_StaticPaymentOutputDescriptorDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::chain::keysinterface::StaticPaymentOutputDescriptor 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 LDKRouteHop {
+typedef struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ {
    /**
-    * 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_StaticPaymentOutputDescriptorDecodeErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   LDKnativeRouteHop *inner;
+   union LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZPtr 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_StaticPaymentOutputDescriptorDecodeErrorZ represents a success state.
     */
-   bool is_owned;
-} LDKRouteHop;
+   bool result_ok;
+} LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ;
 
 /**
- * The contents of CResult_RouteHopDecodeErrorZ
+ * The contents of CResult_SpendableOutputDescriptorDecodeErrorZ
  */
-typedef union LDKCResult_RouteHopDecodeErrorZPtr {
+typedef union LDKCResult_SpendableOutputDescriptorDecodeErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKRouteHop *result;
+   struct LDKSpendableOutputDescriptor *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_RouteHopDecodeErrorZPtr;
+} LDKCResult_SpendableOutputDescriptorDecodeErrorZPtr;
 
 /**
- * A CResult_RouteHopDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::routing::router::RouteHop on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * 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 LDKCResult_RouteHopDecodeErrorZ {
+typedef struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ {
    /**
-    * The contents of this CResult_RouteHopDecodeErrorZ, accessible via either
+    * The contents of this CResult_SpendableOutputDescriptorDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_RouteHopDecodeErrorZPtr contents;
+   union LDKCResult_SpendableOutputDescriptorDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_RouteHopDecodeErrorZ represents a success state.
+    * Whether this CResult_SpendableOutputDescriptorDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_RouteHopDecodeErrorZ;
+} LDKCResult_SpendableOutputDescriptorDecodeErrorZ;
 
 /**
- * A dynamically-allocated array of crate::lightning::routing::router::RouteHops of arbitrary size.
- * This corresponds to std::vector in C++
+ * A tuple of 2 elements. See the individual fields for the types contained.
  */
-typedef struct LDKCVec_RouteHopZ {
+typedef struct LDKC2Tuple_SignatureCVec_SignatureZZ {
    /**
-    * The elements in the array.
-    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+    * The element at position 0
     */
-   struct LDKRouteHop *data;
+   struct LDKSignature a;
    /**
-    * The number of elements pointed to by `data`.
+    * The element at position 1
     */
-   uintptr_t datalen;
-} LDKCVec_RouteHopZ;
+   struct LDKCVec_SignatureZ b;
+} LDKC2Tuple_SignatureCVec_SignatureZZ;
 
 /**
- * A dynamically-allocated array of crate::c_types::derived::CVec_RouteHopZs of arbitrary size.
- * This corresponds to std::vector in C++
+ * The contents of CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ
  */
-typedef struct LDKCVec_CVec_RouteHopZZ {
+typedef union LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZPtr {
    /**
-    * 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 LDKCVec_RouteHopZ *data;
+   struct LDKC2Tuple_SignatureCVec_SignatureZZ *result;
    /**
-    * The number of elements pointed to by `data`.
+    * Note that this value is always NULL, as there are no contents in the Err variant
     */
-   uintptr_t datalen;
-} LDKCVec_CVec_RouteHopZZ;
-
-
+   void *err;
+} LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZPtr;
 
 /**
- * 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 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 MUST_USE_STRUCT LDKRoute {
+typedef struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ {
    /**
-    * 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_SignatureCVec_SignatureZZNoneZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   LDKnativeRoute *inner;
+   union LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZPtr 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_SignatureCVec_SignatureZZNoneZ represents a success state.
     */
-   bool is_owned;
-} LDKRoute;
+   bool result_ok;
+} LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ;
 
 /**
- * The contents of CResult_RouteDecodeErrorZ
+ * The contents of CResult_SignatureNoneZ
  */
-typedef union LDKCResult_RouteDecodeErrorZPtr {
+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 LDKRoute *result;
+   struct LDKSignature *result;
    /**
-    * A pointer to the contents in the error state.
-    * Reading from this pointer when `result_ok` is set is undefined.
+    * Note that this value is always NULL, as there are no contents in the Err variant
     */
-   struct LDKDecodeError *err;
-} LDKCResult_RouteDecodeErrorZPtr;
+   void *err;
+} LDKCResult_SignatureNoneZPtr;
 
 /**
- * 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.
+ * 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 LDKCResult_RouteDecodeErrorZ {
+typedef struct LDKCResult_SignatureNoneZ {
    /**
-    * The contents of this CResult_RouteDecodeErrorZ, accessible via either
+    * The contents of this CResult_SignatureNoneZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_RouteDecodeErrorZPtr contents;
+   union LDKCResult_SignatureNoneZPtr contents;
    /**
-    * Whether this CResult_RouteDecodeErrorZ represents a success state.
+    * Whether this CResult_SignatureNoneZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_RouteDecodeErrorZ;
+} LDKCResult_SignatureNoneZ;
 
 
 
 /**
- * Details of a channel, as returned by ChannelManager::list_channels and ChannelManager::list_usable_channels
+ * The unsigned part of a channel_announcement
  */
-typedef struct MUST_USE_STRUCT LDKChannelDetails {
+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.
     */
-   LDKnativeChannelDetails *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;
-} LDKChannelDetails;
+} LDKUnsignedChannelAnnouncement;
 
 /**
- * A dynamically-allocated array of crate::lightning::ln::channelmanager::ChannelDetailss of arbitrary size.
- * This corresponds to std::vector in C++
+ * 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 struct LDKCVec_ChannelDetailsZ {
+typedef struct LDKBaseSign {
    /**
-    * The elements in the array.
-    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+    * 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 LDKChannelDetails *data;
+   void *this_arg;
    /**
-    * The number of elements pointed to by `data`.
+    * Gets the per-commitment point for a specific commitment number
+    *
+    * Note that the commitment number starts at (1 << 48) - 1 and counts backwards.
     */
-   uintptr_t datalen;
-} LDKCVec_ChannelDetailsZ;
-
-
-
-/**
- * An Err type for failure to process messages.
- */
-typedef struct MUST_USE_STRUCT LDKLightningError {
+   struct LDKPublicKey (*get_per_commitment_point)(const void *this_arg, uint64_t idx);
    /**
-    * 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.
+    * 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.
     */
-   LDKnativeLightningError *inner;
+   struct LDKThirtyTwoBytes (*release_commitment_secret)(const void *this_arg, uint64_t idx);
    /**
-    * 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.
+    * Gets the holder's channel public keys and basepoints
     */
-   bool is_owned;
-} LDKLightningError;
-
-/**
- * The contents of CResult_RouteLightningErrorZ
- */
-typedef union LDKCResult_RouteLightningErrorZPtr {
+   struct LDKChannelPublicKeys pubkeys;
    /**
-    * A pointer to the contents in the success state.
-    * Reading from this pointer when `result_ok` is not set is undefined.
+    * 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 LDKRoute *result;
+   void (*set_pubkeys)(const struct LDKBaseSign*NONNULL_PTR );
    /**
-    * A pointer to the contents in the error state.
-    * Reading from this pointer when `result_ok` is set is undefined.
+    * 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 LDKLightningError *err;
-} LDKCResult_RouteLightningErrorZPtr;
-
-/**
- * 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 {
+   struct LDKThirtyTwoBytes (*channel_keys_id)(const void *this_arg);
    /**
-    * The contents of this CResult_RouteLightningErrorZ, accessible via either
-    * `err` or `result` depending on the state of `result_ok`.
+    * 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.
     */
-   union LDKCResult_RouteLightningErrorZPtr contents;
+   struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ (*sign_counterparty_commitment)(const void *this_arg, const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx);
    /**
-    * Whether this CResult_RouteLightningErrorZ represents a success state.
+    * 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.
     */
-   bool result_ok;
-} LDKCResult_RouteLightningErrorZ;
-
-
-
-/**
- * An accept_channel message to be sent or received from a peer
- */
-typedef struct MUST_USE_STRUCT LDKAcceptChannel {
+   struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ (*sign_holder_commitment_and_htlcs)(const void *this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx);
    /**
-    * 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.
+    * Create a signature for the given input in a transaction spending an HTLC transaction output
+    * or a commitment transaction `to_local` output when our counterparty broadcasts an old state.
+    *
+    * A justice transaction may claim multiple 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 multiple times 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).
+    */
+   struct LDKCResult_SignatureNoneZ (*sign_justice_revoked_output)(const void *this_arg, struct LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (*per_commitment_key)[32]);
+   /**
+    * Create a signature for the given input in a transaction spending a commitment transaction
+    * HTLC output when our counterparty broadcasts an old state.
+    *
+    * A justice transaction may claim multiple 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 multiple times 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), thus changing the format of the witness script
+    * (which is committed to in the BIP 143 signatures).
     */
-   LDKnativeAcceptChannel *inner;
+   struct LDKCResult_SignatureNoneZ (*sign_justice_revoked_htlc)(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);
    /**
-    * 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.
+    * 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.
     */
-   bool is_owned;
-} LDKAcceptChannel;
-
-
-
-/**
- * An open_channel message to be sent or received from a peer
- */
-typedef struct MUST_USE_STRUCT LDKOpenChannel {
+   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);
    /**
-    * 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.
+    * 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.
     */
-   LDKnativeOpenChannel *inner;
+   struct LDKCResult_SignatureNoneZ (*sign_closing_transaction)(const void *this_arg, struct LDKTransaction closing_tx);
    /**
-    * 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.
+    * 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.
     */
-   bool is_owned;
-} LDKOpenChannel;
-
-
-
-/**
- * A funding_created message to be sent or received from a peer
- */
-typedef struct MUST_USE_STRUCT LDKFundingCreated {
+   struct LDKCResult_SignatureNoneZ (*sign_channel_announcement)(const void *this_arg, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg);
    /**
-    * 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.
+    * 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.
     */
-   LDKnativeFundingCreated *inner;
+   void (*ready_channel)(void *this_arg, const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters);
    /**
-    * 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.
+    * 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.
     */
-   bool is_owned;
-} LDKFundingCreated;
-
-
+   void (*free)(void *this_arg);
+} LDKBaseSign;
 
 /**
- * A funding_signed message to be sent or received from a peer
+ * 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 MUST_USE_STRUCT LDKFundingSigned {
+typedef struct LDKSign {
    /**
-    * 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 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.
     */
-   LDKnativeFundingSigned *inner;
+   void *this_arg;
    /**
-    * 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.
+    * Implementation of BaseSign for this object.
     */
-   bool is_owned;
-} LDKFundingSigned;
-
-
-
-/**
- * A funding_locked message to be sent or received from a peer
- */
-typedef struct MUST_USE_STRUCT LDKFundingLocked {
+   struct LDKBaseSign BaseSign;
    /**
-    * 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.
+    * 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.
     */
-   LDKnativeFundingLocked *inner;
+   struct LDKBaseSign (*BaseSign_clone)(const struct LDKBaseSign *NONNULL_PTR orig_BaseSign);
    /**
-    * 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.
+    * Serialize the object into a byte array
     */
-   bool is_owned;
-} LDKFundingLocked;
-
-
-
-/**
- * An announcement_signatures message to be sent or received from a peer
- */
-typedef struct MUST_USE_STRUCT LDKAnnouncementSignatures {
+   struct LDKCVec_u8Z (*write)(const void *this_arg);
    /**
-    * 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.
+    * 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.
     */
-   LDKnativeAnnouncementSignatures *inner;
+   void *(*clone)(const void *this_arg);
    /**
-    * 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.
+    * 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.
     */
-   bool is_owned;
-} LDKAnnouncementSignatures;
-
-
+   void (*free)(void *this_arg);
+} LDKSign;
 
 /**
- * Struct used to return values from revoke_and_ack messages, containing a bunch of commitment
- * transaction updates if they were pending.
+ * The contents of CResult_SignDecodeErrorZ
  */
-typedef struct MUST_USE_STRUCT LDKCommitmentUpdate {
+typedef union LDKCResult_SignDecodeErrorZPtr {
    /**
-    * 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.
     */
-   LDKnativeCommitmentUpdate *inner;
+   struct LDKSign *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;
-} LDKCommitmentUpdate;
-
-
+   struct LDKDecodeError *err;
+} LDKCResult_SignDecodeErrorZPtr;
 
 /**
- * A revoke_and_ack message to be sent or received from a peer
+ * 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 MUST_USE_STRUCT LDKRevokeAndACK {
+typedef struct LDKCResult_SignDecodeErrorZ {
    /**
-    * 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_SignDecodeErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   LDKnativeRevokeAndACK *inner;
+   union LDKCResult_SignDecodeErrorZPtr 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_SignDecodeErrorZ represents a success state.
     */
-   bool is_owned;
-} LDKRevokeAndACK;
-
-
+   bool result_ok;
+} LDKCResult_SignDecodeErrorZ;
 
 /**
- * A closing_signed message to be sent or received from a peer
+ * Represents a secp256k1 signature serialized as two 32-byte numbers as well as a tag which
+ * allows recovering the exact public key which created the signature given the message.
  */
-typedef struct MUST_USE_STRUCT LDKClosingSigned {
-   /**
-    * 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.
-    */
-   LDKnativeClosingSigned *inner;
+typedef struct LDKRecoverableSignature {
    /**
-    * 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 bytes of the signature in "compact" form plus a "Recovery ID" which allows for
+    * recovery.
     */
-   bool is_owned;
-} LDKClosingSigned;
-
-
+   uint8_t serialized_form[68];
+} LDKRecoverableSignature;
 
 /**
- * A shutdown message to be sent or received from a peer
+ * The contents of CResult_RecoverableSignatureNoneZ
  */
-typedef struct MUST_USE_STRUCT LDKShutdown {
+typedef union LDKCResult_RecoverableSignatureNoneZPtr {
    /**
-    * 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.
     */
-   LDKnativeShutdown *inner;
+   struct LDKRecoverableSignature *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;
-} LDKShutdown;
-
-
+   void *err;
+} LDKCResult_RecoverableSignatureNoneZPtr;
 
 /**
- * A channel_reestablish message to be sent or received from a peer
+ * A CResult_RecoverableSignatureNoneZ represents the result of a fallible operation,
+ * containing a crate::c_types::RecoverableSignature on success and a () on failure.
+ * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct MUST_USE_STRUCT LDKChannelReestablish {
+typedef struct LDKCResult_RecoverableSignatureNoneZ {
    /**
-    * 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_RecoverableSignatureNoneZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   LDKnativeChannelReestablish *inner;
+   union LDKCResult_RecoverableSignatureNoneZPtr 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_RecoverableSignatureNoneZ represents a success state.
     */
-   bool is_owned;
-} LDKChannelReestablish;
-
-
+   bool result_ok;
+} LDKCResult_RecoverableSignatureNoneZ;
 
 /**
- * A channel_announcement message to be sent or received from a peer
+ * A dynamically-allocated array of crate::c_types::derived::CVec_u8Zs of arbitrary size.
+ * This corresponds to std::vector in C++
  */
-typedef struct MUST_USE_STRUCT LDKChannelAnnouncement {
+typedef struct LDKCVec_CVec_u8ZZ {
    /**
-    * 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().
     */
-   LDKnativeChannelAnnouncement *inner;
+   struct LDKCVec_u8Z *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;
-} LDKChannelAnnouncement;
-
-
+   uintptr_t datalen;
+} LDKCVec_CVec_u8ZZ;
 
 /**
- * A channel_update message to be sent or received from a peer
+ * The contents of CResult_CVec_CVec_u8ZZNoneZ
  */
-typedef struct MUST_USE_STRUCT LDKChannelUpdate {
+typedef union LDKCResult_CVec_CVec_u8ZZNoneZPtr {
    /**
-    * 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 LDKCVec_CVec_u8ZZ *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_CVec_CVec_u8ZZNoneZPtr;
 
 /**
- * A node_announcement message to be sent or received from a peer
+ * 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 MUST_USE_STRUCT LDKNodeAnnouncement {
+typedef struct LDKCResult_CVec_CVec_u8ZZNoneZ {
    /**
-    * 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_CVec_CVec_u8ZZNoneZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   LDKnativeNodeAnnouncement *inner;
+   union LDKCResult_CVec_CVec_u8ZZNoneZPtr 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_CVec_CVec_u8ZZNoneZ represents a success state.
     */
-   bool is_owned;
-} LDKNodeAnnouncement;
+   bool result_ok;
+} LDKCResult_CVec_CVec_u8ZZNoneZ;
 
 
 
 /**
- * An error message to be sent or received from a peer
+ * 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.
  */
-typedef struct MUST_USE_STRUCT LDKErrorMessage {
+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.
     */
-   LDKnativeErrorMessage *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;
-} LDKErrorMessage;
+} LDKInMemorySigner;
 
 /**
- * Used to put an error message in a LightningError
+ * The contents of CResult_InMemorySignerDecodeErrorZ
  */
-typedef enum LDKErrorAction_Tag {
-   /**
-    * The peer took some action which made us think they were useless. Disconnect them.
-    */
-   LDKErrorAction_DisconnectPeer,
-   /**
-    * The peer did something harmless that we weren't able to process, just log and ignore
-    */
-   LDKErrorAction_IgnoreError,
-   /**
-    * The peer did something incorrect. Tell them.
-    */
-   LDKErrorAction_SendErrorMessage,
-   /**
-    * Must be last for serialization purposes
-    */
-   LDKErrorAction_Sentinel,
-} LDKErrorAction_Tag;
-
-typedef struct LDKErrorAction_LDKDisconnectPeer_Body {
+typedef union LDKCResult_InMemorySignerDecodeErrorZPtr {
    /**
-    * An error message which we should make an effort to send before we disconnect.
+    * A pointer to the contents in the success state.
+    * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKErrorMessage msg;
-} LDKErrorAction_LDKDisconnectPeer_Body;
-
-typedef struct LDKErrorAction_LDKSendErrorMessage_Body {
+   struct LDKInMemorySigner *result;
    /**
-    * The message to send.
+    * A pointer to the contents in the error state.
+    * Reading from this pointer when `result_ok` is set is undefined.
     */
-   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;
+   struct LDKDecodeError *err;
+} LDKCResult_InMemorySignerDecodeErrorZPtr;
 
 /**
- * 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.
+ * 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 enum LDKHTLCFailChannelUpdate_Tag {
-   /**
-    * We received an error which included a full ChannelUpdate message.
-    */
-   LDKHTLCFailChannelUpdate_ChannelUpdateMessage,
-   /**
-    * We received an error which indicated only that a channel has been closed
-    */
-   LDKHTLCFailChannelUpdate_ChannelClosed,
-   /**
-    * We received an error which indicated only that a node has failed
-    */
-   LDKHTLCFailChannelUpdate_NodeFailure,
-   /**
-    * Must be last for serialization purposes
-    */
-   LDKHTLCFailChannelUpdate_Sentinel,
-} LDKHTLCFailChannelUpdate_Tag;
-
-typedef struct LDKHTLCFailChannelUpdate_LDKChannelUpdateMessage_Body {
-   /**
-    * The unwrapped message we received
-    */
-   struct LDKChannelUpdate msg;
-} LDKHTLCFailChannelUpdate_LDKChannelUpdateMessage_Body;
-
-typedef struct LDKHTLCFailChannelUpdate_LDKChannelClosed_Body {
+typedef struct LDKCResult_InMemorySignerDecodeErrorZ {
    /**
-    * The short_channel_id which has now closed.
+    * The contents of this CResult_InMemorySignerDecodeErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   uint64_t short_channel_id;
+   union LDKCResult_InMemorySignerDecodeErrorZPtr contents;
    /**
-    * when this true, this channel should be permanently removed from the
-    * consideration. Otherwise, this channel can be restored as new channel_update is received
+    * Whether this CResult_InMemorySignerDecodeErrorZ represents a success state.
     */
-   bool is_permanent;
-} LDKHTLCFailChannelUpdate_LDKChannelClosed_Body;
+   bool result_ok;
+} LDKCResult_InMemorySignerDecodeErrorZ;
 
-typedef struct LDKHTLCFailChannelUpdate_LDKNodeFailure_Body {
+/**
+ * A dynamically-allocated array of crate::c_types::TxOuts of arbitrary size.
+ * This corresponds to std::vector in C++
+ */
+typedef struct LDKCVec_TxOutZ {
    /**
-    * The node_id that has failed.
+    * The elements in the array.
+    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
     */
-   struct LDKPublicKey node_id;
+   struct LDKTxOut *data;
    /**
-    * 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
+    * The number of elements pointed to by `data`.
     */
-   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;
-
-
+   uintptr_t datalen;
+} LDKCVec_TxOutZ;
 
 /**
- * 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.
+ * The contents of CResult_TransactionNoneZ
  */
-typedef struct MUST_USE_STRUCT LDKQueryChannelRange {
+typedef union LDKCResult_TransactionNoneZPtr {
    /**
-    * 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.
     */
-   LDKnativeQueryChannelRange *inner;
+   struct LDKTransaction *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;
-} LDKQueryChannelRange;
-
-
+   void *err;
+} LDKCResult_TransactionNoneZPtr;
 
 /**
- * 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_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 LDKQueryShortChannelIds {
+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`.
     */
-   LDKnativeQueryShortChannelIds *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;
-} LDKQueryShortChannelIds;
+   bool result_ok;
+} LDKCResult_TransactionNoneZ;
 
 
 
 /**
- * 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 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 LDKReplyChannelRange {
+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.
     */
-   LDKnativeReplyChannelRange *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;
-} LDKReplyChannelRange;
+} LDKChannelMonitor;
 
 /**
- * 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 tuple of 2 elements. See the individual fields for the types contained.
  */
-typedef enum LDKMessageSendEvent_Tag {
-   /**
-    * Used to indicate that we've accepted a channel open and should send the accept_channel
-    * message provided to the given peer.
-    */
-   LDKMessageSendEvent_SendAcceptChannel,
-   /**
-    * Used to indicate that we've initiated a channel open and should send the open_channel
-    * message provided to the given peer.
-    */
-   LDKMessageSendEvent_SendOpenChannel,
-   /**
-    * Used to indicate that a funding_created message should be sent to the peer with the given node_id.
-    */
-   LDKMessageSendEvent_SendFundingCreated,
-   /**
-    * Used to indicate that a funding_signed message should be sent to the peer with the given node_id.
-    */
-   LDKMessageSendEvent_SendFundingSigned,
-   /**
-    * Used to indicate that a funding_locked message should be sent to the peer with the given node_id.
-    */
-   LDKMessageSendEvent_SendFundingLocked,
-   /**
-    * Used to indicate that an announcement_signatures message should be sent to the peer with the given node_id.
-    */
-   LDKMessageSendEvent_SendAnnouncementSignatures,
+typedef struct LDKC2Tuple_BlockHashChannelMonitorZ {
    /**
-    * 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.
+    * The element at position 0
     */
-   LDKMessageSendEvent_UpdateHTLCs,
+   struct LDKThirtyTwoBytes a;
    /**
-    * Used to indicate that a revoke_and_ack message should be sent to the peer with the given node_id.
+    * The element at position 1
     */
-   LDKMessageSendEvent_SendRevokeAndACK,
+   struct LDKChannelMonitor b;
+} LDKC2Tuple_BlockHashChannelMonitorZ;
+
+/**
+ * A dynamically-allocated array of crate::c_types::derived::C2Tuple_BlockHashChannelMonitorZs of arbitrary size.
+ * This corresponds to std::vector in C++
+ */
+typedef struct LDKCVec_C2Tuple_BlockHashChannelMonitorZZ {
    /**
-    * Used to indicate that a closing_signed 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_SendClosingSigned,
+   struct LDKC2Tuple_BlockHashChannelMonitorZ *data;
    /**
-    * Used to indicate that a shutdown message should be sent to the peer with the given node_id.
+    * The number of elements pointed to by `data`.
     */
-   LDKMessageSendEvent_SendShutdown,
+   uintptr_t datalen;
+} LDKCVec_C2Tuple_BlockHashChannelMonitorZZ;
+
+/**
+ * The contents of CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ
+ */
+typedef union LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZPtr {
    /**
-    * Used to indicate that a channel_reestablish 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_SendChannelReestablish,
+   struct LDKCVec_C2Tuple_BlockHashChannelMonitorZZ *result;
    /**
-    * 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.
+    * A pointer to the contents in the error state.
+    * Reading from this pointer when `result_ok` is set is undefined.
     */
-   LDKMessageSendEvent_BroadcastChannelAnnouncement,
+   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 {
    /**
-    * Used to indicate that a node_announcement should be broadcast to all peers.
+    * The contents of this CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   LDKMessageSendEvent_BroadcastNodeAnnouncement,
+   union LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZPtr contents;
    /**
-    * Used to indicate that a channel_update should be broadcast to all peers.
+    * Whether this CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ represents a success state.
     */
-   LDKMessageSendEvent_BroadcastChannelUpdate,
+   bool result_ok;
+} LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ;
+
+/**
+ * Indicates an error on the client's part (usually some variant of attempting to use too-low or
+ * too-high values)
+ */
+typedef enum LDKAPIError_Tag {
    /**
-    * Broadcast an error downstream to be handled
+    * 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.
     */
-   LDKMessageSendEvent_HandleError,
+   LDKAPIError_APIMisuseError,
    /**
-    * 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.
+    * 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.
     */
-   LDKMessageSendEvent_PaymentFailureNetworkUpdate,
+   LDKAPIError_FeeRateTooHigh,
    /**
-    * Query a peer for channels with funding transaction UTXOs in a block range.
+    * A malformed Route was provided (eg overflowed value, node id mismatch, overly-looped route,
+    * too-many-hops, etc).
     */
-   LDKMessageSendEvent_SendChannelRangeQuery,
+   LDKAPIError_RouteError,
    /**
-    * Request routing gossip messages from a peer for a list of channels identified by
-    * their short_channel_ids.
+    * 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.
     */
-   LDKMessageSendEvent_SendShortIdsQuery,
+   LDKAPIError_ChannelUnavailable,
    /**
-    * Sends a reply to a channel range query. This may be one of several SendReplyChannelRange events
-    * emitted during processing of the query.
+    * An attempt to call watch/update_channel returned an Err (ie you did this!), causing the
+    * attempted action to fail.
     */
-   LDKMessageSendEvent_SendReplyChannelRange,
+   LDKAPIError_MonitorUpdateFailed,
    /**
     * Must be last for serialization purposes
     */
-   LDKMessageSendEvent_Sentinel,
-} LDKMessageSendEvent_Tag;
-
-typedef struct LDKMessageSendEvent_LDKSendAcceptChannel_Body {
-   /**
-    * The node_id of the node which should receive this message
-    */
-   struct LDKPublicKey node_id;
-   /**
-    * The message which should be sent.
-    */
-   struct LDKAcceptChannel msg;
-} LDKMessageSendEvent_LDKSendAcceptChannel_Body;
+   LDKAPIError_Sentinel,
+} LDKAPIError_Tag;
 
-typedef struct LDKMessageSendEvent_LDKSendOpenChannel_Body {
-   /**
-    * The node_id of the node which should receive this message
-    */
-   struct LDKPublicKey node_id;
+typedef struct LDKAPIError_LDKAPIMisuseError_Body {
    /**
-    * The message which should be sent.
+    * A human-readable error message
     */
-   struct LDKOpenChannel msg;
-} LDKMessageSendEvent_LDKSendOpenChannel_Body;
+   struct LDKStr err;
+} LDKAPIError_LDKAPIMisuseError_Body;
 
-typedef struct LDKMessageSendEvent_LDKSendFundingCreated_Body {
+typedef struct LDKAPIError_LDKFeeRateTooHigh_Body {
    /**
-    * The node_id of the node which should receive this message
+    * A human-readable error message
     */
-   struct LDKPublicKey node_id;
+   struct LDKStr err;
    /**
-    * The message which should be sent.
+    * The feerate which was too high.
     */
-   struct LDKFundingCreated msg;
-} LDKMessageSendEvent_LDKSendFundingCreated_Body;
+   uint32_t feerate;
+} LDKAPIError_LDKFeeRateTooHigh_Body;
 
-typedef struct LDKMessageSendEvent_LDKSendFundingSigned_Body {
-   /**
-    * The node_id of the node which should receive this message
-    */
-   struct LDKPublicKey node_id;
+typedef struct LDKAPIError_LDKRouteError_Body {
    /**
-    * The message which should be sent.
+    * A human-readable error message
     */
-   struct LDKFundingSigned msg;
-} LDKMessageSendEvent_LDKSendFundingSigned_Body;
+   struct LDKStr err;
+} LDKAPIError_LDKRouteError_Body;
 
-typedef struct LDKMessageSendEvent_LDKSendFundingLocked_Body {
-   /**
-    * The node_id of the node which should receive these message(s)
-    */
-   struct LDKPublicKey node_id;
+typedef struct LDKAPIError_LDKChannelUnavailable_Body {
    /**
-    * The funding_locked message which should be sent.
+    * A human-readable error message
     */
-   struct LDKFundingLocked msg;
-} LDKMessageSendEvent_LDKSendFundingLocked_Body;
+   struct LDKStr err;
+} LDKAPIError_LDKChannelUnavailable_Body;
 
-typedef struct LDKMessageSendEvent_LDKSendAnnouncementSignatures_Body {
-   /**
-    * The node_id of the node which should receive these message(s)
-    */
-   struct LDKPublicKey node_id;
-   /**
-    * The announcement_signatures message which should be sent.
-    */
-   struct LDKAnnouncementSignatures msg;
-} LDKMessageSendEvent_LDKSendAnnouncementSignatures_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;
 
-typedef struct LDKMessageSendEvent_LDKUpdateHTLCs_Body {
+/**
+ * The contents of CResult_NoneAPIErrorZ
+ */
+typedef union LDKCResult_NoneAPIErrorZPtr {
    /**
-    * The node_id of the node which should receive these message(s)
+    * Note that this value is always NULL, as there are no contents in the OK variant
     */
-   struct LDKPublicKey node_id;
+   void *result;
    /**
-    * The update messages which should be sent. ALL messages in the struct should be sent!
+    * A pointer to the contents in the error state.
+    * Reading from this pointer when `result_ok` is set is undefined.
     */
-   struct LDKCommitmentUpdate updates;
-} LDKMessageSendEvent_LDKUpdateHTLCs_Body;
+   struct LDKAPIError *err;
+} LDKCResult_NoneAPIErrorZPtr;
 
-typedef struct LDKMessageSendEvent_LDKSendRevokeAndACK_Body {
+/**
+ * A CResult_NoneAPIErrorZ represents the result of a fallible operation,
+ * containing a () on success and a crate::lightning::util::errors::APIError on failure.
+ * `result_ok` indicates the overall state, and the contents are provided via `contents`.
+ */
+typedef struct LDKCResult_NoneAPIErrorZ {
    /**
-    * The node_id of the node which should receive this message
+    * The contents of this CResult_NoneAPIErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   struct LDKPublicKey node_id;
+   union LDKCResult_NoneAPIErrorZPtr contents;
    /**
-    * The message which should be sent.
+    * Whether this CResult_NoneAPIErrorZ represents a success state.
     */
-   struct LDKRevokeAndACK msg;
-} LDKMessageSendEvent_LDKSendRevokeAndACK_Body;
+   bool result_ok;
+} LDKCResult_NoneAPIErrorZ;
 
-typedef struct LDKMessageSendEvent_LDKSendClosingSigned_Body {
+/**
+ * A dynamically-allocated array of crate::c_types::derived::CResult_NoneAPIErrorZs of arbitrary size.
+ * This corresponds to std::vector in C++
+ */
+typedef struct LDKCVec_CResult_NoneAPIErrorZZ {
    /**
-    * The node_id of the node which should receive this message
+    * The elements in the array.
+    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
     */
-   struct LDKPublicKey node_id;
+   struct LDKCResult_NoneAPIErrorZ *data;
    /**
-    * The message which should be sent.
+    * The number of elements pointed to by `data`.
     */
-   struct LDKClosingSigned msg;
-} LDKMessageSendEvent_LDKSendClosingSigned_Body;
+   uintptr_t datalen;
+} LDKCVec_CResult_NoneAPIErrorZZ;
 
-typedef struct LDKMessageSendEvent_LDKSendShutdown_Body {
+/**
+ * A dynamically-allocated array of crate::lightning::util::errors::APIErrors of arbitrary size.
+ * This corresponds to std::vector in C++
+ */
+typedef struct LDKCVec_APIErrorZ {
    /**
-    * The node_id of the node which should receive this message
+    * The elements in the array.
+    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
     */
-   struct LDKPublicKey node_id;
+   struct LDKAPIError *data;
    /**
-    * The message which should be sent.
+    * The number of elements pointed to by `data`.
     */
-   struct LDKShutdown msg;
-} LDKMessageSendEvent_LDKSendShutdown_Body;
+   uintptr_t datalen;
+} LDKCVec_APIErrorZ;
 
-typedef struct LDKMessageSendEvent_LDKSendChannelReestablish_Body {
+/**
+ * If a payment fails to send, it can be in one of several states. This enum is returned as the
+ * Err() type describing which state the payment is in, see the description of individual enum
+ * states for more.
+ */
+typedef enum LDKPaymentSendFailure_Tag {
    /**
-    * The node_id of the node which should receive this message
+    * 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.
     */
-   struct LDKPublicKey node_id;
+   LDKPaymentSendFailure_ParameterError,
    /**
-    * The message which should be sent.
+    * 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.
     */
-   struct LDKChannelReestablish msg;
-} LDKMessageSendEvent_LDKSendChannelReestablish_Body;
-
-typedef struct LDKMessageSendEvent_LDKBroadcastChannelAnnouncement_Body {
+   LDKPaymentSendFailure_PathParameterError,
    /**
-    * The channel_announcement which should be sent.
+    * 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).
     */
-   struct LDKChannelAnnouncement msg;
+   LDKPaymentSendFailure_AllFailedRetrySafe,
    /**
-    * The followup channel_update which should be sent.
+    * 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.
     */
-   struct LDKChannelUpdate update_msg;
-} LDKMessageSendEvent_LDKBroadcastChannelAnnouncement_Body;
-
-typedef struct LDKMessageSendEvent_LDKBroadcastNodeAnnouncement_Body {
+   LDKPaymentSendFailure_PartialFailure,
    /**
-    * The node_announcement which should be sent.
+    * Must be last for serialization purposes
     */
-   struct LDKNodeAnnouncement msg;
-} LDKMessageSendEvent_LDKBroadcastNodeAnnouncement_Body;
+   LDKPaymentSendFailure_Sentinel,
+} LDKPaymentSendFailure_Tag;
 
-typedef struct LDKMessageSendEvent_LDKBroadcastChannelUpdate_Body {
+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;
+
+/**
+ * The contents of CResult_NonePaymentSendFailureZ
+ */
+typedef union LDKCResult_NonePaymentSendFailureZPtr {
    /**
-    * The channel_update which should be sent.
+    * Note that this value is always NULL, as there are no contents in the OK variant
     */
-   struct LDKChannelUpdate msg;
-} LDKMessageSendEvent_LDKBroadcastChannelUpdate_Body;
+   void *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;
 
-typedef struct LDKMessageSendEvent_LDKHandleError_Body {
+/**
+ * A CResult_NonePaymentSendFailureZ represents the result of a fallible operation,
+ * containing a () on success and a crate::lightning::ln::channelmanager::PaymentSendFailure on failure.
+ * `result_ok` indicates the overall state, and the contents are provided via `contents`.
+ */
+typedef struct LDKCResult_NonePaymentSendFailureZ {
    /**
-    * The node_id of the node which should receive this message
+    * The contents of this CResult_NonePaymentSendFailureZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   struct LDKPublicKey node_id;
+   union LDKCResult_NonePaymentSendFailureZPtr contents;
    /**
-    * The action which should be taken.
+    * Whether this CResult_NonePaymentSendFailureZ represents a success state.
     */
-   struct LDKErrorAction action;
-} LDKMessageSendEvent_LDKHandleError_Body;
+   bool result_ok;
+} LDKCResult_NonePaymentSendFailureZ;
 
-typedef struct LDKMessageSendEvent_LDKPaymentFailureNetworkUpdate_Body {
+/**
+ * A 4-byte byte array.
+ */
+typedef struct LDKFourBytes {
    /**
-    * The channel/node update which should be sent to NetGraphMsgHandler
+    * The four bytes
     */
-   struct LDKHTLCFailChannelUpdate update;
-} LDKMessageSendEvent_LDKPaymentFailureNetworkUpdate_Body;
+   uint8_t data[4];
+} LDKFourBytes;
 
-typedef struct LDKMessageSendEvent_LDKSendChannelRangeQuery_Body {
+/**
+ * A 16-byte byte array.
+ */
+typedef struct LDKSixteenBytes {
    /**
-    * The node_id of this message recipient
+    * The sixteen bytes
     */
-   struct LDKPublicKey node_id;
+   uint8_t data[16];
+} LDKSixteenBytes;
+
+/**
+ * A 10-byte byte array.
+ */
+typedef struct LDKTenBytes {
    /**
-    * The query_channel_range which should be sent.
+    * The ten bytes
     */
-   struct LDKQueryChannelRange msg;
-} LDKMessageSendEvent_LDKSendChannelRangeQuery_Body;
+   uint8_t data[10];
+} LDKTenBytes;
 
-typedef struct LDKMessageSendEvent_LDKSendShortIdsQuery_Body {
+/**
+ * An address which can be used to connect to a remote peer
+ */
+typedef enum LDKNetAddress_Tag {
    /**
-    * The node_id of this message recipient
+    * An IPv4 address/port on which the peer is listening.
     */
-   struct LDKPublicKey node_id;
+   LDKNetAddress_IPv4,
    /**
-    * The query_short_channel_ids which should be sent.
+    * An IPv6 address/port on which the peer is listening.
     */
-   struct LDKQueryShortChannelIds msg;
-} LDKMessageSendEvent_LDKSendShortIdsQuery_Body;
-
-typedef struct LDKMessageSendEvent_LDKSendReplyChannelRange_Body {
+   LDKNetAddress_IPv6,
    /**
-    * The node_id of this message recipient
+    * An old-style Tor onion address/port on which the peer is listening.
     */
-   struct LDKPublicKey node_id;
+   LDKNetAddress_OnionV2,
    /**
-    * The reply_channel_range which should be sent.
-    */
-   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 new-style Tor onion address/port on which the peer is listening.
+    * To create the human-readable \"hostname\", concatenate ed25519_pubkey, checksum, and version,
+    * wrap as base32 and append \".onion\".
+    */
+   LDKNetAddress_OnionV3,
+   /**
+    * Must be last for serialization purposes
+    */
+   LDKNetAddress_Sentinel,
+} LDKNetAddress_Tag;
 
-/**
- * A dynamically-allocated array of crate::lightning::util::events::MessageSendEvents of arbitrary size.
- * This corresponds to std::vector in C++
- */
-typedef struct LDKCVec_MessageSendEventZ {
+typedef struct LDKNetAddress_LDKIPv4_Body {
    /**
-    * The elements in the array.
-    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+    * The 4-byte IPv4 address
     */
-   struct LDKMessageSendEvent *data;
+   struct LDKFourBytes addr;
    /**
-    * The number of elements pointed to by `data`.
+    * The port on which the node is listening
     */
-   uintptr_t datalen;
-} LDKCVec_MessageSendEventZ;
+   uint16_t port;
+} LDKNetAddress_LDKIPv4_Body;
 
-/**
- * The contents of CResult_boolLightningErrorZ
- */
-typedef union LDKCResult_boolLightningErrorZPtr {
+typedef struct LDKNetAddress_LDKIPv6_Body {
    /**
-    * A pointer to the contents in the success state.
-    * Reading from this pointer when `result_ok` is not set is undefined.
+    * The 16-byte IPv6 address
     */
-   bool *result;
+   struct LDKSixteenBytes addr;
    /**
-    * A pointer to the contents in the error state.
-    * Reading from this pointer when `result_ok` is set is undefined.
+    * The port on which the node is listening
     */
-   struct LDKLightningError *err;
-} LDKCResult_boolLightningErrorZPtr;
+   uint16_t port;
+} LDKNetAddress_LDKIPv6_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 {
+typedef struct LDKNetAddress_LDKOnionV2_Body {
    /**
-    * The contents of this CResult_boolLightningErrorZ, accessible via either
-    * `err` or `result` depending on the state of `result_ok`.
+    * The bytes (usually encoded in base32 with \".onion\" appended)
     */
-   union LDKCResult_boolLightningErrorZPtr contents;
+   struct LDKTenBytes addr;
    /**
-    * Whether this CResult_boolLightningErrorZ represents a success state.
+    * The port on which the node is listening
     */
-   bool result_ok;
-} LDKCResult_boolLightningErrorZ;
+   uint16_t port;
+} LDKNetAddress_LDKOnionV2_Body;
 
-/**
- * A tuple of 3 elements. See the individual fields for the types contained.
- */
-typedef struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ {
+typedef struct LDKNetAddress_LDKOnionV3_Body {
    /**
-    * The element at position 0
+    * The ed25519 long-term public key of the peer
     */
-   struct LDKChannelAnnouncement a;
+   struct LDKThirtyTwoBytes ed25519_pubkey;
    /**
-    * The element at position 1
+    * The checksum of the pubkey and version, as included in the onion address
     */
-   struct LDKChannelUpdate b;
+   uint16_t checksum;
    /**
-    * The element at position 2
+    * The version byte, as defined by the Tor Onion v3 spec.
     */
-   struct LDKChannelUpdate c;
-} LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ;
+   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::c_types::derived::C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZs of arbitrary size.
+ * A dynamically-allocated array of crate::lightning::ln::msgs::NetAddresss of arbitrary size.
  * This corresponds to std::vector in C++
  */
-typedef struct LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
+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 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *data;
+   struct LDKNetAddress *data;
    /**
     * The number of elements pointed to by `data`.
     */
    uintptr_t datalen;
-} LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ;
+} LDKCVec_NetAddressZ;
 
 /**
- * A dynamically-allocated array of crate::lightning::ln::msgs::NodeAnnouncements of arbitrary size.
- * This corresponds to std::vector in C++
+ * A tuple of 2 elements. See the individual fields for the types contained.
  */
-typedef struct LDKCVec_NodeAnnouncementZ {
+typedef struct LDKC2Tuple_PaymentHashPaymentSecretZ {
    /**
-    * The elements in the array.
-    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+    * The element at position 0
     */
-   struct LDKNodeAnnouncement *data;
+   struct LDKThirtyTwoBytes a;
    /**
-    * The number of elements pointed to by `data`.
+    * The element at position 1
     */
-   uintptr_t datalen;
-} LDKCVec_NodeAnnouncementZ;
+   struct LDKThirtyTwoBytes b;
+} LDKC2Tuple_PaymentHashPaymentSecretZ;
 
 /**
- * The contents of CResult_NoneLightningErrorZ
+ * The contents of CResult_PaymentSecretAPIErrorZ
  */
-typedef union LDKCResult_NoneLightningErrorZPtr {
+typedef union LDKCResult_PaymentSecretAPIErrorZPtr {
    /**
-    * 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 LDKThirtyTwoBytes *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
-   struct LDKLightningError *err;
-} LDKCResult_NoneLightningErrorZPtr;
+   struct LDKAPIError *err;
+} LDKCResult_PaymentSecretAPIErrorZPtr;
 
 /**
- * A CResult_NoneLightningErrorZ represents the result of a fallible operation,
- * containing a () on success and a crate::lightning::ln::msgs::LightningError on failure.
+ * A CResult_PaymentSecretAPIErrorZ represents the result of a fallible operation,
+ * containing a crate::c_types::ThirtyTwoBytes on success and a crate::lightning::util::errors::APIError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_NoneLightningErrorZ {
+typedef struct LDKCResult_PaymentSecretAPIErrorZ {
    /**
-    * The contents of this CResult_NoneLightningErrorZ, accessible via either
+    * The contents of this CResult_PaymentSecretAPIErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_NoneLightningErrorZPtr contents;
+   union LDKCResult_PaymentSecretAPIErrorZPtr contents;
    /**
-    * Whether this CResult_NoneLightningErrorZ represents a success state.
+    * Whether this CResult_PaymentSecretAPIErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_NoneLightningErrorZ;
+} LDKCResult_PaymentSecretAPIErrorZ;
 
 /**
- * A dynamically-allocated array of crate::c_types::PublicKeys of arbitrary size.
+ * A dynamically-allocated array of crate::lightning::chain::channelmonitor::ChannelMonitors of arbitrary size.
  * This corresponds to std::vector in C++
  */
-typedef struct LDKCVec_PublicKeyZ {
+typedef struct LDKCVec_ChannelMonitorZ {
    /**
     * The elements in the array.
     * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
     */
-   struct LDKPublicKey *data;
+   struct LDKChannelMonitor *data;
    /**
     * The number of elements pointed to by `data`.
     */
    uintptr_t datalen;
-} LDKCVec_PublicKeyZ;
+} LDKCVec_ChannelMonitorZ;
 
 
 
 /**
- * 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.
+ * 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 LDKPeerHandleError {
+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.
     */
-   LDKnativePeerHandleError *inner;
+   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;
-} LDKPeerHandleError;
-
-/**
- * The contents of CResult_CVec_u8ZPeerHandleErrorZ
- */
-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 LDKCVec_u8Z *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_CVec_u8ZPeerHandleErrorZPtr;
+} LDKChannelMonitorUpdate;
 
 /**
- * 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`.
+ * 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
  */
-typedef struct LDKCResult_CVec_u8ZPeerHandleErrorZ {
-   /**
-    * The contents of this CResult_CVec_u8ZPeerHandleErrorZ, accessible via either
-    * `err` or `result` depending on the state of `result_ok`.
-    */
-   union LDKCResult_CVec_u8ZPeerHandleErrorZPtr contents;
+typedef struct LDKWatch {
    /**
-    * Whether this CResult_CVec_u8ZPeerHandleErrorZ represents a success state.
+    * 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.
     */
-   bool result_ok;
-} LDKCResult_CVec_u8ZPeerHandleErrorZ;
-
-/**
- * The contents of CResult_NonePeerHandleErrorZ
- */
-typedef union LDKCResult_NonePeerHandleErrorZPtr {
+   void *this_arg;
    /**
-    * Note that this value is always NULL, as there are no contents in the OK variant
+    * 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
     */
-   void *result;
+   struct LDKCResult_NoneChannelMonitorUpdateErrZ (*watch_channel)(const void *this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor);
    /**
-    * A pointer to the contents in the error state.
-    * Reading from this pointer when `result_ok` is set is undefined.
+    * 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
     */
-   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 {
+   struct LDKCResult_NoneChannelMonitorUpdateErrZ (*update_channel)(const void *this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitorUpdate update);
    /**
-    * The contents of this CResult_NonePeerHandleErrorZ, accessible via either
-    * `err` or `result` depending on the state of `result_ok`.
+    * Returns any monitor events since the last call. Subsequent calls must only return new
+    * events.
     */
-   union LDKCResult_NonePeerHandleErrorZPtr contents;
+   struct LDKCVec_MonitorEventZ (*release_pending_monitor_events)(const void *this_arg);
    /**
-    * Whether this CResult_NonePeerHandleErrorZ represents a success state.
+    * 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.
     */
-   bool result_ok;
-} LDKCResult_NonePeerHandleErrorZ;
+   void (*free)(void *this_arg);
+} LDKWatch;
 
 /**
- * The contents of CResult_boolPeerHandleErrorZ
+ * An interface to send a transaction to the Bitcoin network.
  */
-typedef union LDKCResult_boolPeerHandleErrorZPtr {
+typedef struct LDKBroadcasterInterface {
    /**
-    * A pointer to the contents in the success state.
-    * Reading from this pointer when `result_ok` is not set is undefined.
+    * 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.
     */
-   bool *result;
+   void *this_arg;
    /**
-    * A pointer to the contents in the error state.
-    * Reading from this pointer when `result_ok` is set is undefined.
+    * Sends a transaction out to (hopefully) be mined.
     */
-   struct LDKPeerHandleError *err;
-} LDKCResult_boolPeerHandleErrorZPtr;
+   void (*broadcast_transaction)(const void *this_arg, struct LDKTransaction tx);
+   /**
+    * 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);
+} LDKBroadcasterInterface;
 
 /**
- * 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`.
+ * A "slice" referencing some byte array. This is simply a length-tagged pointer which does not
+ * own the memory pointed to by data.
  */
-typedef struct LDKCResult_boolPeerHandleErrorZ {
+typedef struct LDKu8slice {
    /**
-    * The contents of this CResult_boolPeerHandleErrorZ, accessible via either
-    * `err` or `result` depending on the state of `result_ok`.
+    * A pointer to the byte buffer
     */
-   union LDKCResult_boolPeerHandleErrorZPtr contents;
+   const uint8_t *data;
    /**
-    * Whether this CResult_boolPeerHandleErrorZ represents a success state.
+    * The number of bytes pointed to by `data`.
     */
-   bool result_ok;
-} LDKCResult_boolPeerHandleErrorZ;
+   uintptr_t datalen;
+} LDKu8slice;
 
 /**
- * The contents of CResult_TxOutAccessErrorZ
+ * A trait to describe an object which can get user secrets and key material.
  */
-typedef union LDKCResult_TxOutAccessErrorZPtr {
+typedef struct LDKKeysInterface {
    /**
-    * A pointer to the contents in the success state.
-    * Reading from this pointer when `result_ok` is not set is undefined.
+    * 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 LDKTxOut *result;
+   void *this_arg;
    /**
-    * A pointer to the contents in the error state.
-    * Reading from this pointer when `result_ok` is set is undefined.
+    * Get node secret key (aka node_id or network_key).
+    *
+    * This method must return the same value each time it is called.
     */
-   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 {
+   struct LDKSecretKey (*get_node_secret)(const void *this_arg);
    /**
-    * The contents of this CResult_TxOutAccessErrorZ, accessible via either
-    * `err` or `result` depending on the state of `result_ok`.
+    * 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.
     */
-   union LDKCResult_TxOutAccessErrorZPtr contents;
+   struct LDKCVec_u8Z (*get_destination_script)(const void *this_arg);
    /**
-    * Whether this CResult_TxOutAccessErrorZ represents a success state.
+    * 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.
     */
-   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 {
+   struct LDKPublicKey (*get_shutdown_pubkey)(const void *this_arg);
    /**
-    * When we're in this state, this COption_C2Tuple_usizeTransactionZZ contains a crate::c_types::derived::C2Tuple_usizeTransactionZ
+    * 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.
     */
-   LDKCOption_C2Tuple_usizeTransactionZZ_Some,
+   struct LDKSign (*get_channel_signer)(const void *this_arg, bool inbound, uint64_t channel_value_satoshis);
    /**
-    * When we're in this state, this COption_C2Tuple_usizeTransactionZZ contains nothing
+    * 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.
     */
-   LDKCOption_C2Tuple_usizeTransactionZZ_None,
+   struct LDKThirtyTwoBytes (*get_secure_random_bytes)(const void *this_arg);
    /**
-    * Must be last for serialization purposes
+    * 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.
     */
-   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;
-
-
-
-/**
- * Details about one direction of a channel. Received
- * within a channel update.
- */
-typedef struct MUST_USE_STRUCT LDKDirectionalChannelInfo {
+   struct LDKCResult_SignDecodeErrorZ (*read_chan_signer)(const void *this_arg, struct LDKu8slice reader);
    /**
-    * 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.
+    * Sign an invoice's preimage (note that this is the preimage of the invoice, not the HTLC's
+    * preimage). By parameterizing by the preimage instead of the hash, we allow implementors of
+    * this trait to parse the invoice and make sure they're signing what they expect, rather than
+    * blindly signing the hash.
     */
-   LDKnativeDirectionalChannelInfo *inner;
+   struct LDKCResult_RecoverableSignatureNoneZ (*sign_invoice)(const void *this_arg, struct LDKCVec_u8Z invoice_preimage);
    /**
-    * 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.
+    * 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.
     */
-   bool is_owned;
-} LDKDirectionalChannelInfo;
+   void (*free)(void *this_arg);
+} LDKKeysInterface;
 
 /**
- * The contents of CResult_DirectionalChannelInfoDecodeErrorZ
+ * 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 union LDKCResult_DirectionalChannelInfoDecodeErrorZPtr {
+typedef struct LDKFeeEstimator {
    /**
-    * A pointer to the contents in the success state.
-    * Reading from this pointer when `result_ok` is not set is undefined.
+    * 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 LDKDirectionalChannelInfo *result;
+   void *this_arg;
    /**
-    * A pointer to the contents in the error state.
-    * Reading from this pointer when `result_ok` is set is undefined.
+    * 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)
     */
-   struct LDKDecodeError *err;
-} LDKCResult_DirectionalChannelInfoDecodeErrorZPtr;
+   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.
+    */
+   void (*free)(void *this_arg);
+} LDKFeeEstimator;
 
 /**
- * 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`.
+ * A trait encapsulating the operations required of a logger
  */
-typedef struct LDKCResult_DirectionalChannelInfoDecodeErrorZ {
+typedef struct LDKLogger {
    /**
-    * The contents of this CResult_DirectionalChannelInfoDecodeErrorZ, accessible via either
-    * `err` or `result` depending on the state of `result_ok`.
+    * 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.
     */
-   union LDKCResult_DirectionalChannelInfoDecodeErrorZPtr contents;
+   void *this_arg;
    /**
-    * Whether this CResult_DirectionalChannelInfoDecodeErrorZ represents a success state.
+    * Logs the `Record`
     */
-   bool result_ok;
-} LDKCResult_DirectionalChannelInfoDecodeErrorZ;
+   void (*log)(const void *this_arg, const char *record);
+   /**
+    * 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);
+} LDKLogger;
 
 
 
 /**
- * Details about a channel (both directions).
- * Received within a channel announcement.
+ * 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.
+ *
+ * Rather than using a plain ChannelManager, it is preferable to use either a SimpleArcChannelManager
+ * a SimpleRefChannelManager, for conciseness. See their documentation for more details, but
+ * essentially you should default to using a SimpleRefChannelManager, and use a
+ * SimpleArcChannelManager when you require a ChannelManager with a static lifetime, such as when
+ * you're using lightning-net-tokio.
  */
-typedef struct MUST_USE_STRUCT LDKChannelInfo {
+typedef struct MUST_USE_STRUCT LDKChannelManager {
    /**
     * 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.
     */
-   LDKnativeChannelInfo *inner;
+   LDKnativeChannelManager *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;
-} LDKChannelInfo;
+} LDKChannelManager;
 
 /**
- * The contents of CResult_ChannelInfoDecodeErrorZ
+ * A tuple of 2 elements. See the individual fields for the types contained.
  */
-typedef union LDKCResult_ChannelInfoDecodeErrorZPtr {
+typedef struct LDKC2Tuple_BlockHashChannelManagerZ {
+   /**
+    * The element at position 0
+    */
+   struct LDKThirtyTwoBytes a;
+   /**
+    * The element at position 1
+    */
+   struct LDKChannelManager b;
+} LDKC2Tuple_BlockHashChannelManagerZ;
+
+/**
+ * The contents of CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ
+ */
+typedef union LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKChannelInfo *result;
+   struct LDKC2Tuple_BlockHashChannelManagerZ *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_ChannelInfoDecodeErrorZPtr;
+} LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZPtr;
 
 /**
- * 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.
+ * 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.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_ChannelInfoDecodeErrorZ {
+typedef struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ {
    /**
-    * The contents of this CResult_ChannelInfoDecodeErrorZ, accessible via either
+    * The contents of this CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_ChannelInfoDecodeErrorZPtr contents;
+   union LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_ChannelInfoDecodeErrorZ represents a success state.
+    * Whether this CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_ChannelInfoDecodeErrorZ;
+} LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ;
 
 
 
 /**
- * Fees for routing via a given channel or a node
+ * Options which apply on a per-channel basis and may change at runtime or based on negotiation
+ * with our counterparty.
  */
-typedef struct MUST_USE_STRUCT LDKRoutingFees {
+typedef struct MUST_USE_STRUCT LDKChannelConfig {
    /**
     * 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.
     */
-   LDKnativeRoutingFees *inner;
+   LDKnativeChannelConfig *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;
-} LDKRoutingFees;
+} LDKChannelConfig;
 
 /**
- * The contents of CResult_RoutingFeesDecodeErrorZ
+ * The contents of CResult_ChannelConfigDecodeErrorZ
  */
-typedef union LDKCResult_RoutingFeesDecodeErrorZPtr {
+typedef union LDKCResult_ChannelConfigDecodeErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKRoutingFees *result;
+   struct LDKChannelConfig *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_RoutingFeesDecodeErrorZPtr;
+} LDKCResult_ChannelConfigDecodeErrorZPtr;
 
 /**
- * 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.
+ * A CResult_ChannelConfigDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::util::config::ChannelConfig 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 LDKCResult_ChannelConfigDecodeErrorZ {
    /**
-    * The contents of this CResult_RoutingFeesDecodeErrorZ, accessible via either
+    * The contents of this CResult_ChannelConfigDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_RoutingFeesDecodeErrorZPtr contents;
+   union LDKCResult_ChannelConfigDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_RoutingFeesDecodeErrorZ represents a success state.
+    * Whether this CResult_ChannelConfigDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_RoutingFeesDecodeErrorZ;
+} LDKCResult_ChannelConfigDecodeErrorZ;
 
 /**
- * A 4-byte byte array.
+ * The contents of CResult_OutPointDecodeErrorZ
  */
-typedef struct LDKFourBytes {
+typedef union LDKCResult_OutPointDecodeErrorZPtr {
    /**
-    * The four bytes
+    * A pointer to the contents in the success state.
+    * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   uint8_t data[4];
-} LDKFourBytes;
-
-/**
- * A 16-byte byte array.
- */
-typedef struct LDKSixteenBytes {
+   struct LDKOutPoint *result;
    /**
-    * The sixteen bytes
+    * A pointer to the contents in the error state.
+    * Reading from this pointer when `result_ok` is set is undefined.
     */
-   uint8_t data[16];
-} LDKSixteenBytes;
+   struct LDKDecodeError *err;
+} LDKCResult_OutPointDecodeErrorZPtr;
 
 /**
- * A 10-byte byte array.
+ * A CResult_OutPointDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::chain::transaction::OutPoint 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 LDKTenBytes {
+typedef struct LDKCResult_OutPointDecodeErrorZ {
    /**
-    * The ten bytes
+    * The contents of this CResult_OutPointDecodeErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   uint8_t data[10];
-} LDKTenBytes;
+   union LDKCResult_OutPointDecodeErrorZPtr contents;
+   /**
+    * Whether this CResult_OutPointDecodeErrorZ represents a success state.
+    */
+   bool result_ok;
+} LDKCResult_OutPointDecodeErrorZ;
 
 /**
- * An address which can be used to connect to a remote peer
+ * The contents of CResult_SiPrefixNoneZ
  */
-typedef enum LDKNetAddress_Tag {
-   /**
-    * An IPv4 address/port on which the peer is listening.
-    */
-   LDKNetAddress_IPv4,
+typedef union LDKCResult_SiPrefixNoneZPtr {
    /**
-    * An IPv6 address/port on which the peer is listening.
+    * A pointer to the contents in the success state.
+    * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   LDKNetAddress_IPv6,
+   enum LDKSiPrefix *result;
    /**
-    * An old-style Tor onion address/port on which the peer is listening.
+    * Note that this value is always NULL, as there are no contents in the Err variant
     */
-   LDKNetAddress_OnionV2,
+   void *err;
+} LDKCResult_SiPrefixNoneZPtr;
+
+/**
+ * A CResult_SiPrefixNoneZ represents the result of a fallible operation,
+ * containing a crate::lightning_invoice::SiPrefix on success and a () on failure.
+ * `result_ok` indicates the overall state, and the contents are provided via `contents`.
+ */
+typedef struct LDKCResult_SiPrefixNoneZ {
    /**
-    * 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 contents of this CResult_SiPrefixNoneZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   LDKNetAddress_OnionV3,
+   union LDKCResult_SiPrefixNoneZPtr contents;
    /**
-    * Must be last for serialization purposes
+    * Whether this CResult_SiPrefixNoneZ represents a success state.
     */
-   LDKNetAddress_Sentinel,
-} LDKNetAddress_Tag;
+   bool result_ok;
+} LDKCResult_SiPrefixNoneZ;
 
-typedef struct LDKNetAddress_LDKIPv4_Body {
+
+
+/**
+ * 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 MUST_USE_STRUCT LDKInvoice {
    /**
-    * The 4-byte IPv4 address
+    * 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 LDKFourBytes addr;
+   LDKnativeInvoice *inner;
    /**
-    * The port on which the node is listening
+    * 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.
     */
-   uint16_t port;
-} LDKNetAddress_LDKIPv4_Body;
+   bool is_owned;
+} LDKInvoice;
 
-typedef struct LDKNetAddress_LDKIPv6_Body {
+/**
+ * The contents of CResult_InvoiceNoneZ
+ */
+typedef union LDKCResult_InvoiceNoneZPtr {
    /**
-    * The 16-byte IPv6 address
+    * A pointer to the contents in the success state.
+    * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKSixteenBytes addr;
+   struct LDKInvoice *result;
    /**
-    * The port on which the node is listening
+    * Note that this value is always NULL, as there are no contents in the Err variant
     */
-   uint16_t port;
-} LDKNetAddress_LDKIPv6_Body;
+   void *err;
+} LDKCResult_InvoiceNoneZPtr;
 
-typedef struct LDKNetAddress_LDKOnionV2_Body {
+/**
+ * A CResult_InvoiceNoneZ represents the result of a fallible operation,
+ * containing a crate::lightning_invoice::Invoice on success and a () on failure.
+ * `result_ok` indicates the overall state, and the contents are provided via `contents`.
+ */
+typedef struct LDKCResult_InvoiceNoneZ {
    /**
-    * The bytes (usually encoded in base32 with \".onion\" appended)
+    * The contents of this CResult_InvoiceNoneZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   struct LDKTenBytes addr;
+   union LDKCResult_InvoiceNoneZPtr contents;
    /**
-    * The port on which the node is listening
+    * Whether this CResult_InvoiceNoneZ represents a success state.
     */
-   uint16_t port;
-} LDKNetAddress_LDKOnionV2_Body;
+   bool result_ok;
+} LDKCResult_InvoiceNoneZ;
 
-typedef struct LDKNetAddress_LDKOnionV3_Body {
+
+
+/**
+ * Represents a signed `RawInvoice` with cached hash. The signature is not checked and may be
+ * invalid.
+ *
+ * # Invariants
+ * The hash has to be either from the deserialized invoice or from the serialized `raw_invoice`.
+ */
+typedef struct MUST_USE_STRUCT LDKSignedRawInvoice {
    /**
-    * The ed25519 long-term public key of the peer
+    * 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 LDKThirtyTwoBytes ed25519_pubkey;
+   LDKnativeSignedRawInvoice *inner;
    /**
-    * The checksum of the pubkey and version, as included in the onion address
+    * 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.
     */
-   uint16_t checksum;
+   bool is_owned;
+} LDKSignedRawInvoice;
+
+/**
+ * The contents of CResult_SignedRawInvoiceNoneZ
+ */
+typedef union LDKCResult_SignedRawInvoiceNoneZPtr {
    /**
-    * The version byte, as defined by the Tor Onion v3 spec.
+    * A pointer to the contents in the success state.
+    * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   uint8_t version;
+   struct LDKSignedRawInvoice *result;
    /**
-    * The port on which the node is listening
+    * Note that this value is always NULL, as there are no contents in the Err variant
     */
-   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;
+   void *err;
+} LDKCResult_SignedRawInvoiceNoneZPtr;
 
 /**
- * A dynamically-allocated array of crate::lightning::ln::msgs::NetAddresss of arbitrary size.
- * This corresponds to std::vector in C++
+ * A CResult_SignedRawInvoiceNoneZ represents the result of a fallible operation,
+ * containing a crate::lightning_invoice::SignedRawInvoice on success and a () on failure.
+ * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCVec_NetAddressZ {
+typedef struct LDKCResult_SignedRawInvoiceNoneZ {
    /**
-    * 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_SignedRawInvoiceNoneZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   struct LDKNetAddress *data;
+   union LDKCResult_SignedRawInvoiceNoneZPtr contents;
    /**
-    * The number of elements pointed to by `data`.
+    * Whether this CResult_SignedRawInvoiceNoneZ represents a success state.
     */
-   uintptr_t datalen;
-} LDKCVec_NetAddressZ;
+   bool result_ok;
+} LDKCResult_SignedRawInvoiceNoneZ;
 
 
 
 /**
- * Information received in the latest node_announcement from this node.
+ * 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 LDKNodeAnnouncementInfo {
+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.
     */
-   LDKnativeNodeAnnouncementInfo *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;
-} LDKNodeAnnouncementInfo;
+} LDKRawInvoice;
+
+
 
 /**
- * The contents of CResult_NodeAnnouncementInfoDecodeErrorZ
+ * Recoverable signature
  */
-typedef union LDKCResult_NodeAnnouncementInfoDecodeErrorZPtr {
+typedef struct MUST_USE_STRUCT LDKInvoiceSignature {
    /**
-    * 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 LDKNodeAnnouncementInfo *result;
+   LDKnativeInvoiceSignature *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_NodeAnnouncementInfoDecodeErrorZPtr;
+   bool is_owned;
+} LDKInvoiceSignature;
 
 /**
- * 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 {
-   /**
-    * The contents of this CResult_NodeAnnouncementInfoDecodeErrorZ, accessible via either
-    * `err` or `result` depending on the state of `result_ok`.
-    */
-   union LDKCResult_NodeAnnouncementInfoDecodeErrorZPtr contents;
+typedef struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ {
    /**
-    * Whether this CResult_NodeAnnouncementInfoDecodeErrorZ represents a success state.
+    * The element at position 0
     */
-   bool result_ok;
-} LDKCResult_NodeAnnouncementInfoDecodeErrorZ;
-
-/**
- * A dynamically-allocated array of u64s of arbitrary size.
- * This corresponds to std::vector in C++
- */
-typedef struct LDKCVec_u64Z {
+   struct LDKRawInvoice a;
    /**
-    * The elements in the array.
-    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+    * The element at position 1
     */
-   uint64_t *data;
+   struct LDKThirtyTwoBytes b;
    /**
-    * The number of elements pointed to by `data`.
+    * The element at position 2
     */
-   uintptr_t datalen;
-} LDKCVec_u64Z;
+   struct LDKInvoiceSignature c;
+} LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ;
 
 
 
 /**
- * Details about a node in the network, known from the network announcement.
+ * Payee public key
  */
-typedef struct MUST_USE_STRUCT LDKNodeInfo {
+typedef struct MUST_USE_STRUCT LDKPayeePubKey {
    /**
     * 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.
     */
-   LDKnativeNodeInfo *inner;
+   LDKnativePayeePubKey *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;
-} LDKNodeInfo;
+} LDKPayeePubKey;
 
 /**
- * The contents of CResult_NodeInfoDecodeErrorZ
+ * The contents of CResult_PayeePubKeyErrorZ
  */
-typedef union LDKCResult_NodeInfoDecodeErrorZPtr {
+typedef union LDKCResult_PayeePubKeyErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKNodeInfo *result;
+   struct LDKPayeePubKey *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;
+   enum LDKSecp256k1Error *err;
+} LDKCResult_PayeePubKeyErrorZPtr;
 
 /**
- * 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_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_NodeInfoDecodeErrorZ {
+typedef struct LDKCResult_PayeePubKeyErrorZ {
    /**
-    * The contents of this CResult_NodeInfoDecodeErrorZ, accessible via either
+    * The contents of this CResult_PayeePubKeyErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_NodeInfoDecodeErrorZPtr contents;
+   union LDKCResult_PayeePubKeyErrorZPtr contents;
    /**
-    * Whether this CResult_NodeInfoDecodeErrorZ represents a success state.
+    * Whether this CResult_PayeePubKeyErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_NodeInfoDecodeErrorZ;
+} LDKCResult_PayeePubKeyErrorZ;
 
 
 
 /**
- * Represents the network as nodes and channels between them
+ * Private routing information
+ *
+ * # Invariants
+ * The encoded route has to be <1024 5bit characters long (<=639 bytes or <=12 hops)
+ *
  */
-typedef struct MUST_USE_STRUCT LDKNetworkGraph {
+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.
     */
-   LDKnativeNetworkGraph *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;
-} LDKNetworkGraph;
+} LDKRouteHint;
 
 /**
- * The contents of CResult_NetworkGraphDecodeErrorZ
+ * A dynamically-allocated array of crate::lightning_invoice::RouteHints of arbitrary size.
+ * This corresponds to std::vector in C++
  */
-typedef union LDKCResult_NetworkGraphDecodeErrorZPtr {
+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 LDKRouteHint *data;
+   /**
+    * The number of elements pointed to by `data`.
+    */
+   uintptr_t datalen;
+} LDKCVec_RouteHintZ;
+
+
+
+/**
+ * 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 {
+   /**
+    * 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.
+    */
+   LDKnativePositiveTimestamp *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;
+} LDKPositiveTimestamp;
+
+/**
+ * The contents of CResult_PositiveTimestampCreationErrorZ
+ */
+typedef union LDKCResult_PositiveTimestampCreationErrorZPtr {
    /**
     * 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 LDKPositiveTimestamp *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;
+   enum LDKCreationError *err;
+} LDKCResult_PositiveTimestampCreationErrorZPtr;
 
 /**
- * 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_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_NetworkGraphDecodeErrorZ {
+typedef struct LDKCResult_PositiveTimestampCreationErrorZ {
    /**
-    * The contents of this CResult_NetworkGraphDecodeErrorZ, accessible via either
+    * The contents of this CResult_PositiveTimestampCreationErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_NetworkGraphDecodeErrorZPtr contents;
+   union LDKCResult_PositiveTimestampCreationErrorZPtr contents;
    /**
-    * Whether this CResult_NetworkGraphDecodeErrorZ represents a success state.
+    * Whether this CResult_PositiveTimestampCreationErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_NetworkGraphDecodeErrorZ;
-
+} LDKCResult_PositiveTimestampCreationErrorZ;
 
+/**
+ * The contents of CResult_NoneSemanticErrorZ
+ */
+typedef union LDKCResult_NoneSemanticErrorZPtr {
+   /**
+    * 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.
+    */
+   enum LDKSemanticError *err;
+} LDKCResult_NoneSemanticErrorZPtr;
 
 /**
- * Features used within an `init` message.
+ * 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 MUST_USE_STRUCT LDKInitFeatures {
+typedef struct LDKCResult_NoneSemanticErrorZ {
    /**
-    * 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_NoneSemanticErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   LDKnativeInitFeatures *inner;
+   union LDKCResult_NoneSemanticErrorZPtr 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_NoneSemanticErrorZ represents a success state.
     */
-   bool is_owned;
-} LDKInitFeatures;
+   bool result_ok;
+} LDKCResult_NoneSemanticErrorZ;
 
 /**
- * The contents of CResult_InitFeaturesDecodeErrorZ
+ * The contents of CResult_InvoiceSemanticErrorZ
  */
-typedef union LDKCResult_InitFeaturesDecodeErrorZPtr {
+typedef union LDKCResult_InvoiceSemanticErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKInitFeatures *result;
+   struct LDKInvoice *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;
+   enum LDKSemanticError *err;
+} LDKCResult_InvoiceSemanticErrorZPtr;
 
 /**
- * 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_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 LDKCResult_InitFeaturesDecodeErrorZ {
+typedef struct LDKCResult_InvoiceSemanticErrorZ {
    /**
-    * The contents of this CResult_InitFeaturesDecodeErrorZ, accessible via either
+    * The contents of this CResult_InvoiceSemanticErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_InitFeaturesDecodeErrorZPtr contents;
+   union LDKCResult_InvoiceSemanticErrorZPtr contents;
    /**
-    * Whether this CResult_InitFeaturesDecodeErrorZ represents a success state.
+    * Whether this CResult_InvoiceSemanticErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_InitFeaturesDecodeErrorZ;
+} LDKCResult_InvoiceSemanticErrorZ;
 
 
 
 /**
- * Features used within a `node_announcement` message.
+ * Description string
+ *
+ * # Invariants
+ * The description can be at most 639 __bytes__ long
  */
-typedef struct MUST_USE_STRUCT LDKNodeFeatures {
+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.
     */
-   LDKnativeNodeFeatures *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;
-} LDKNodeFeatures;
+} LDKDescription;
 
 /**
- * The contents of CResult_NodeFeaturesDecodeErrorZ
+ * The contents of CResult_DescriptionCreationErrorZ
  */
-typedef union LDKCResult_NodeFeaturesDecodeErrorZPtr {
+typedef union LDKCResult_DescriptionCreationErrorZPtr {
    /**
     * 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 LDKDescription *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 LDKCreationError *err;
+} LDKCResult_DescriptionCreationErrorZPtr;
 
 /**
- * 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_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 LDKCResult_NodeFeaturesDecodeErrorZ {
+typedef struct LDKCResult_DescriptionCreationErrorZ {
    /**
-    * The contents of this CResult_NodeFeaturesDecodeErrorZ, accessible via either
+    * The contents of this CResult_DescriptionCreationErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_NodeFeaturesDecodeErrorZPtr contents;
+   union LDKCResult_DescriptionCreationErrorZPtr contents;
    /**
-    * Whether this CResult_NodeFeaturesDecodeErrorZ represents a success state.
+    * Whether this CResult_DescriptionCreationErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_NodeFeaturesDecodeErrorZ;
+} LDKCResult_DescriptionCreationErrorZ;
 
 
 
 /**
- * Features used within a `channel_announcement` message.
+ * 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 MUST_USE_STRUCT LDKChannelFeatures {
+typedef struct MUST_USE_STRUCT LDKExpiryTime {
    /**
     * 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;
+   LDKnativeExpiryTime *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;
+} LDKExpiryTime;
 
 /**
- * The contents of CResult_ChannelFeaturesDecodeErrorZ
+ * The contents of CResult_ExpiryTimeCreationErrorZ
  */
-typedef union LDKCResult_ChannelFeaturesDecodeErrorZPtr {
+typedef union LDKCResult_ExpiryTimeCreationErrorZPtr {
    /**
     * 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 LDKExpiryTime *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;
+   enum LDKCreationError *err;
+} LDKCResult_ExpiryTimeCreationErrorZPtr;
 
 /**
- * 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_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 LDKCResult_ChannelFeaturesDecodeErrorZ {
+typedef struct LDKCResult_ExpiryTimeCreationErrorZ {
    /**
-    * The contents of this CResult_ChannelFeaturesDecodeErrorZ, accessible via either
+    * The contents of this CResult_ExpiryTimeCreationErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_ChannelFeaturesDecodeErrorZPtr contents;
+   union LDKCResult_ExpiryTimeCreationErrorZPtr contents;
    /**
-    * Whether this CResult_ChannelFeaturesDecodeErrorZ represents a success state.
+    * Whether this CResult_ExpiryTimeCreationErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_ChannelFeaturesDecodeErrorZ;
-
-
-
-/**
- * Features used within an invoice.
- */
-typedef struct MUST_USE_STRUCT LDKInvoiceFeatures {
-   /**
-    * 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;
-   /**
-    * 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;
+} LDKCResult_ExpiryTimeCreationErrorZ;
 
 /**
- * The contents of CResult_InvoiceFeaturesDecodeErrorZ
+ * The contents of CResult_RouteHintCreationErrorZ
  */
-typedef union LDKCResult_InvoiceFeaturesDecodeErrorZPtr {
+typedef union LDKCResult_RouteHintCreationErrorZPtr {
    /**
     * 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 LDKRouteHint *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;
+   enum LDKCreationError *err;
+} LDKCResult_RouteHintCreationErrorZPtr;
 
 /**
- * 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_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_InvoiceFeaturesDecodeErrorZ {
+typedef struct LDKCResult_RouteHintCreationErrorZ {
    /**
-    * The contents of this CResult_InvoiceFeaturesDecodeErrorZ, accessible via either
+    * The contents of this CResult_RouteHintCreationErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_InvoiceFeaturesDecodeErrorZPtr contents;
+   union LDKCResult_RouteHintCreationErrorZPtr contents;
    /**
-    * Whether this CResult_InvoiceFeaturesDecodeErrorZ represents a success state.
+    * Whether this CResult_RouteHintCreationErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_InvoiceFeaturesDecodeErrorZ;
+} LDKCResult_RouteHintCreationErrorZ;
 
 /**
- * The contents of CResult_NetAddressu8Z
+ * The contents of CResult_StringErrorZ
  */
-typedef union LDKCResult_NetAddressu8ZPtr {
+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 LDKNetAddress *result;
+   struct LDKStr *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;
+   enum LDKSecp256k1Error *err;
+} LDKCResult_StringErrorZPtr;
 
 /**
- * A CResult_NetAddressu8Z represents the result of a fallible operation,
- * containing a crate::lightning::ln::msgs::NetAddress on success and a u8 on failure.
+ * A CResult_StringErrorZ represents the result of a fallible operation,
+ * containing a crate::c_types::Str 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_NetAddressu8Z {
+typedef struct LDKCResult_StringErrorZ {
    /**
-    * The contents of this CResult_NetAddressu8Z, accessible via either
+    * The contents of this CResult_StringErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_NetAddressu8ZPtr contents;
+   union LDKCResult_StringErrorZPtr contents;
    /**
-    * Whether this CResult_NetAddressu8Z represents a success state.
+    * Whether this CResult_StringErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_NetAddressu8Z;
+} LDKCResult_StringErrorZ;
 
 /**
- * The contents of CResult_CResult_NetAddressu8ZDecodeErrorZ
+ * The contents of CResult_ChannelMonitorUpdateDecodeErrorZ
  */
-typedef union LDKCResult_CResult_NetAddressu8ZDecodeErrorZPtr {
+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 LDKCResult_NetAddressu8Z *result;
+   struct LDKChannelMonitorUpdate *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_ChannelMonitorUpdateDecodeErrorZPtr;
 
 /**
- * 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_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_CResult_NetAddressu8ZDecodeErrorZ {
+typedef struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ {
    /**
-    * The contents of this CResult_CResult_NetAddressu8ZDecodeErrorZ, accessible via either
+    * The contents of this CResult_ChannelMonitorUpdateDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_CResult_NetAddressu8ZDecodeErrorZPtr contents;
+   union LDKCResult_ChannelMonitorUpdateDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_CResult_NetAddressu8ZDecodeErrorZ represents a success state.
+    * Whether this CResult_ChannelMonitorUpdateDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_CResult_NetAddressu8ZDecodeErrorZ;
+} LDKCResult_ChannelMonitorUpdateDecodeErrorZ;
 
 /**
- * The contents of CResult_NetAddressDecodeErrorZ
+ * The contents of CResult_HTLCUpdateDecodeErrorZ
  */
-typedef union LDKCResult_NetAddressDecodeErrorZPtr {
+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 LDKNetAddress *result;
+   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_NetAddressDecodeErrorZPtr;
+} LDKCResult_HTLCUpdateDecodeErrorZPtr;
 
 /**
- * A CResult_NetAddressDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::ln::msgs::NetAddress on success and a crate::lightning::ln::msgs::DecodeError 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_NetAddressDecodeErrorZ {
+typedef struct LDKCResult_HTLCUpdateDecodeErrorZ {
    /**
-    * The contents of this CResult_NetAddressDecodeErrorZ, accessible via either
+    * The contents of this CResult_HTLCUpdateDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_NetAddressDecodeErrorZPtr contents;
+   union LDKCResult_HTLCUpdateDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_NetAddressDecodeErrorZ represents a success state.
+    * Whether this CResult_HTLCUpdateDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_NetAddressDecodeErrorZ;
+} LDKCResult_HTLCUpdateDecodeErrorZ;
 
 
 
 /**
- * An update_add_htlc message to be sent or received from a peer
+ * 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 LDKUpdateAddHTLC {
+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.
     */
-   LDKnativeUpdateAddHTLC *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;
-} LDKUpdateAddHTLC;
+} LDKMonitorUpdateError;
 
 /**
- * A dynamically-allocated array of crate::lightning::ln::msgs::UpdateAddHTLCs of arbitrary size.
- * This corresponds to std::vector in C++
+ * The contents of CResult_NoneMonitorUpdateErrorZ
  */
-typedef struct LDKCVec_UpdateAddHTLCZ {
+typedef union LDKCResult_NoneMonitorUpdateErrorZPtr {
    /**
-    * The elements in the array.
-    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+    * Note that this value is always NULL, as there are no contents in the OK variant
     */
-   struct LDKUpdateAddHTLC *data;
+   void *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_UpdateAddHTLCZ;
+   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 {
+   /**
+    * The contents of this CResult_NoneMonitorUpdateErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
+    */
+   union LDKCResult_NoneMonitorUpdateErrorZPtr contents;
+   /**
+    * Whether this CResult_NoneMonitorUpdateErrorZ represents a success state.
+    */
+   bool result_ok;
+} LDKCResult_NoneMonitorUpdateErrorZ;
 
+/**
+ * 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;
+   /**
+    * The element at position 1
+    */
+   struct LDKCVec_u8Z b;
+} LDKC2Tuple_OutPointScriptZ;
 
 /**
- * An update_fulfill_htlc 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 LDKUpdateFulfillHTLC {
+typedef struct LDKC2Tuple_u32ScriptZ {
    /**
-    * 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
     */
-   LDKnativeUpdateFulfillHTLC *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;
-} LDKUpdateFulfillHTLC;
+   struct LDKCVec_u8Z b;
+} LDKC2Tuple_u32ScriptZ;
 
 /**
- * A dynamically-allocated array of crate::lightning::ln::msgs::UpdateFulfillHTLCs of arbitrary size.
+ * A dynamically-allocated array of crate::c_types::derived::C2Tuple_u32ScriptZs of arbitrary size.
  * This corresponds to std::vector in C++
  */
-typedef struct LDKCVec_UpdateFulfillHTLCZ {
+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 LDKUpdateFulfillHTLC *data;
+   struct LDKC2Tuple_u32ScriptZ *data;
    /**
     * The number of elements pointed to by `data`.
     */
    uintptr_t datalen;
-} LDKCVec_UpdateFulfillHTLCZ;
-
-
+} LDKCVec_C2Tuple_u32ScriptZZ;
 
 /**
- * An update_fail_htlc 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 LDKUpdateFailHTLC {
+typedef struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ {
    /**
-    * 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
     */
-   LDKnativeUpdateFailHTLC *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;
-} LDKUpdateFailHTLC;
+   struct LDKCVec_C2Tuple_u32ScriptZZ b;
+} LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ;
 
 /**
- * A dynamically-allocated array of crate::lightning::ln::msgs::UpdateFailHTLCs of arbitrary size.
+ * 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_UpdateFailHTLCZ {
+typedef struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ {
    /**
     * 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 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *data;
    /**
     * The number of elements pointed to by `data`.
     */
    uintptr_t datalen;
-} LDKCVec_UpdateFailHTLCZ;
-
-
+} LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ;
 
 /**
- * An update_fail_malformed_htlc message to be sent or received from a peer
+ * 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 struct MUST_USE_STRUCT LDKUpdateFailMalformedHTLC {
+typedef enum LDKEvent_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.
+    * 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!
     */
-   LDKnativeUpdateFailMalformedHTLC *inner;
+   LDKEvent_FundingGenerationReady,
    /**
-    * 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.
+    * 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.
     */
-   bool is_owned;
-} LDKUpdateFailMalformedHTLC;
+   LDKEvent_PaymentReceived,
+   /**
+    * Indicates an outbound payment we made succeeded (ie it made it all the way to its target
+    * and we got back the payment preimage for it).
+    */
+   LDKEvent_PaymentSent,
+   /**
+    * Indicates an outbound payment we made failed. Probably some intermediary node dropped
+    * something. You may wish to retry with a different route.
+    */
+   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;
 
-/**
- * A dynamically-allocated array of crate::lightning::ln::msgs::UpdateFailMalformedHTLCs of arbitrary size.
- * This corresponds to std::vector in C++
- */
-typedef struct LDKCVec_UpdateFailMalformedHTLCZ {
+typedef struct LDKEvent_LDKFundingGenerationReady_Body {
    /**
-    * The elements in the array.
-    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+    * The random channel_id we picked which you'll need to pass into
+    * ChannelManager::funding_transaction_generated.
     */
-   struct LDKUpdateFailMalformedHTLC *data;
+   struct LDKThirtyTwoBytes temporary_channel_id;
    /**
-    * The number of elements pointed to by `data`.
+    * The value, in satoshis, that the output should have.
     */
-   uintptr_t datalen;
-} LDKCVec_UpdateFailMalformedHTLCZ;
+   uint64_t channel_value_satoshis;
+   /**
+    * The script which should be used in the transaction output.
+    */
+   struct LDKCVec_u8Z output_script;
+   /**
+    * The value passed in to ChannelManager::create_channel
+    */
+   uint64_t user_channel_id;
+} LDKEvent_LDKFundingGenerationReady_Body;
 
-/**
- * The contents of CResult_AcceptChannelDecodeErrorZ
- */
-typedef union LDKCResult_AcceptChannelDecodeErrorZPtr {
+typedef struct LDKEvent_LDKPaymentReceived_Body {
    /**
-    * A pointer to the contents in the success state.
-    * Reading from this pointer when `result_ok` is not set is undefined.
+    * The hash for which the preimage should be handed to the ChannelManager.
     */
-   struct LDKAcceptChannel *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.
+    * 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
     */
-   struct LDKDecodeError *err;
-} LDKCResult_AcceptChannelDecodeErrorZPtr;
+   struct LDKThirtyTwoBytes payment_preimage;
+   /**
+    * 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 LDKThirtyTwoBytes payment_secret;
+   /**
+    * 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!).
+    */
+   uint64_t amt;
+   /**
+    * 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
+    */
+   uint64_t user_payment_id;
+} LDKEvent_LDKPaymentReceived_Body;
 
-/**
- * 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_AcceptChannelDecodeErrorZ {
+typedef struct LDKEvent_LDKPaymentSent_Body {
    /**
-    * The contents of this CResult_AcceptChannelDecodeErrorZ, accessible via either
-    * `err` or `result` depending on the state of `result_ok`.
+    * 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!
     */
-   union LDKCResult_AcceptChannelDecodeErrorZPtr contents;
+   struct LDKThirtyTwoBytes payment_preimage;
+} LDKEvent_LDKPaymentSent_Body;
+
+typedef struct LDKEvent_LDKPaymentFailed_Body {
    /**
-    * Whether this CResult_AcceptChannelDecodeErrorZ represents a success state.
+    * The hash which was given to ChannelManager::send_payment.
     */
-   bool result_ok;
-} LDKCResult_AcceptChannelDecodeErrorZ;
+   struct LDKThirtyTwoBytes payment_hash;
+   /**
+    * 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.
+    */
+   bool rejected_by_dest;
+} LDKEvent_LDKPaymentFailed_Body;
 
-/**
- * The contents of CResult_AnnouncementSignaturesDecodeErrorZ
- */
-typedef union LDKCResult_AnnouncementSignaturesDecodeErrorZPtr {
+typedef struct LDKEvent_LDKPendingHTLCsForwardable_Body {
    /**
-    * A pointer to the contents in the success state.
-    * Reading from this pointer when `result_ok` is not set is undefined.
+    * 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).
     */
-   struct LDKAnnouncementSignatures *result;
+   uint64_t time_forwardable;
+} LDKEvent_LDKPendingHTLCsForwardable_Body;
+
+typedef struct LDKEvent_LDKSpendableOutputs_Body {
    /**
-    * A pointer to the contents in the error state.
-    * Reading from this pointer when `result_ok` is set is undefined.
+    * The outputs which you should store as spendable by you.
     */
-   struct LDKDecodeError *err;
-} LDKCResult_AnnouncementSignaturesDecodeErrorZPtr;
+   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;
 
 /**
- * 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`.
+ * A dynamically-allocated array of crate::lightning::util::events::Events of arbitrary size.
+ * This corresponds to std::vector in C++
  */
-typedef struct LDKCResult_AnnouncementSignaturesDecodeErrorZ {
+typedef struct LDKCVec_EventZ {
    /**
-    * The contents of this CResult_AnnouncementSignaturesDecodeErrorZ, 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_AnnouncementSignaturesDecodeErrorZPtr contents;
+   struct LDKEvent *data;
    /**
-    * Whether this CResult_AnnouncementSignaturesDecodeErrorZ represents a success state.
+    * The number of elements pointed to by `data`.
     */
-   bool result_ok;
-} LDKCResult_AnnouncementSignaturesDecodeErrorZ;
+   uintptr_t datalen;
+} LDKCVec_EventZ;
 
 /**
- * The contents of CResult_ChannelReestablishDecodeErrorZ
+ * A dynamically-allocated array of crate::c_types::Transactions of arbitrary size.
+ * This corresponds to std::vector in C++
  */
-typedef union LDKCResult_ChannelReestablishDecodeErrorZPtr {
+typedef struct LDKCVec_TransactionZ {
    /**
-    * 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 LDKChannelReestablish *result;
+   struct LDKTransaction *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_ChannelReestablishDecodeErrorZPtr;
+   uintptr_t datalen;
+} LDKCVec_TransactionZ;
 
 /**
- * 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`.
+ * A tuple of 2 elements. See the individual fields for the types contained.
  */
-typedef struct LDKCResult_ChannelReestablishDecodeErrorZ {
+typedef struct LDKC2Tuple_u32TxOutZ {
    /**
-    * The contents of this CResult_ChannelReestablishDecodeErrorZ, accessible via either
-    * `err` or `result` depending on the state of `result_ok`.
+    * The element at position 0
     */
-   union LDKCResult_ChannelReestablishDecodeErrorZPtr contents;
+   uint32_t a;
    /**
-    * Whether this CResult_ChannelReestablishDecodeErrorZ represents a success state.
+    * The element at position 1
     */
-   bool result_ok;
-} LDKCResult_ChannelReestablishDecodeErrorZ;
+   struct LDKTxOut b;
+} LDKC2Tuple_u32TxOutZ;
 
 /**
- * The contents of CResult_ClosingSignedDecodeErrorZ
+ * A dynamically-allocated array of crate::c_types::derived::C2Tuple_u32TxOutZs of arbitrary size.
+ * This corresponds to std::vector in C++
  */
-typedef union LDKCResult_ClosingSignedDecodeErrorZPtr {
+typedef struct LDKCVec_C2Tuple_u32TxOutZZ {
    /**
-    * 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 LDKClosingSigned *result;
+   struct LDKC2Tuple_u32TxOutZ *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_ClosingSignedDecodeErrorZPtr;
+   uintptr_t datalen;
+} LDKCVec_C2Tuple_u32TxOutZZ;
 
 /**
- * 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`.
+ * A tuple of 2 elements. See the individual fields for the types contained.
  */
-typedef struct LDKCResult_ClosingSignedDecodeErrorZ {
+typedef struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ {
    /**
-    * The contents of this CResult_ClosingSignedDecodeErrorZ, accessible via either
-    * `err` or `result` depending on the state of `result_ok`.
+    * The element at position 0
     */
-   union LDKCResult_ClosingSignedDecodeErrorZPtr contents;
+   struct LDKThirtyTwoBytes a;
    /**
-    * Whether this CResult_ClosingSignedDecodeErrorZ represents a success state.
+    * The element at position 1
     */
-   bool result_ok;
-} LDKCResult_ClosingSignedDecodeErrorZ;
-
-
+   struct LDKCVec_C2Tuple_u32TxOutZZ b;
+} LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ;
 
 /**
- * A commitment_signed 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 LDKCommitmentSigned {
+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().
     */
-   LDKnativeCommitmentSigned *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;
-} LDKCommitmentSigned;
+   uintptr_t datalen;
+} LDKCVec_TransactionOutputsZ;
 
 /**
- * The contents of CResult_CommitmentSignedDecodeErrorZ
+ * The contents of CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ
  */
-typedef union LDKCResult_CommitmentSignedDecodeErrorZPtr {
+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 LDKCommitmentSigned *result;
+   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_CommitmentSignedDecodeErrorZPtr;
+} LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZPtr;
 
 /**
- * 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_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_CommitmentSignedDecodeErrorZ {
+typedef struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ {
    /**
-    * The contents of this CResult_CommitmentSignedDecodeErrorZ, accessible via either
+    * The contents of this CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_CommitmentSignedDecodeErrorZPtr contents;
+   union LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_CommitmentSignedDecodeErrorZ represents a success state.
+    * Whether this CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_CommitmentSignedDecodeErrorZ;
+} LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ;
 
 /**
- * The contents of CResult_FundingCreatedDecodeErrorZ
+ * The contents of CResult_boolLightningErrorZ
  */
-typedef union LDKCResult_FundingCreatedDecodeErrorZPtr {
+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.
     */
-   struct LDKFundingCreated *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_FundingCreatedDecodeErrorZPtr;
+   struct LDKLightningError *err;
+} LDKCResult_boolLightningErrorZPtr;
 
 /**
- * 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.
+ * 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_FundingCreatedDecodeErrorZ {
+typedef struct LDKCResult_boolLightningErrorZ {
    /**
-    * The contents of this CResult_FundingCreatedDecodeErrorZ, accessible via either
+    * The contents of this CResult_boolLightningErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_FundingCreatedDecodeErrorZPtr contents;
+   union LDKCResult_boolLightningErrorZPtr contents;
    /**
-    * Whether this CResult_FundingCreatedDecodeErrorZ represents a success state.
+    * Whether this CResult_boolLightningErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_FundingCreatedDecodeErrorZ;
+} LDKCResult_boolLightningErrorZ;
 
 /**
- * The contents of CResult_FundingSignedDecodeErrorZ
+ * A tuple of 3 elements. See the individual fields for the types contained.
  */
-typedef union LDKCResult_FundingSignedDecodeErrorZPtr {
+typedef struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ {
    /**
-    * A pointer to the contents in the success state.
-    * Reading from this pointer when `result_ok` is not set is undefined.
+    * The element at position 0
     */
-   struct LDKFundingSigned *result;
+   struct LDKChannelAnnouncement a;
    /**
-    * A pointer to the contents in the error state.
-    * Reading from this pointer when `result_ok` is set is undefined.
+    * The element at position 1
     */
-   struct LDKDecodeError *err;
-} LDKCResult_FundingSignedDecodeErrorZPtr;
+   struct LDKChannelUpdate b;
+   /**
+    * The element at position 2
+    */
+   struct LDKChannelUpdate c;
+} LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ;
 
 /**
- * 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`.
+ * A dynamically-allocated array of crate::c_types::derived::C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZs of arbitrary size.
+ * This corresponds to std::vector in C++
  */
-typedef struct LDKCResult_FundingSignedDecodeErrorZ {
+typedef struct LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
    /**
-    * The contents of this CResult_FundingSignedDecodeErrorZ, 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_FundingSignedDecodeErrorZPtr contents;
+   struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *data;
    /**
-    * Whether this CResult_FundingSignedDecodeErrorZ represents a success state.
+    * The number of elements pointed to by `data`.
     */
-   bool result_ok;
-} LDKCResult_FundingSignedDecodeErrorZ;
+   uintptr_t datalen;
+} LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ;
 
 /**
- * The contents of CResult_FundingLockedDecodeErrorZ
+ * A dynamically-allocated array of crate::lightning::ln::msgs::NodeAnnouncements of arbitrary size.
+ * This corresponds to std::vector in C++
  */
-typedef union LDKCResult_FundingLockedDecodeErrorZPtr {
+typedef struct LDKCVec_NodeAnnouncementZ {
    /**
-    * 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 LDKFundingLocked *result;
+   struct LDKNodeAnnouncement *data;
+   /**
+    * The number of elements pointed to by `data`.
+    */
+   uintptr_t datalen;
+} LDKCVec_NodeAnnouncementZ;
+
+/**
+ * The contents of CResult_NoneLightningErrorZ
+ */
+typedef union LDKCResult_NoneLightningErrorZPtr {
+   /**
+    * 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 LDKDecodeError *err;
-} LDKCResult_FundingLockedDecodeErrorZPtr;
+   struct LDKLightningError *err;
+} LDKCResult_NoneLightningErrorZPtr;
 
 /**
- * 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_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_FundingLockedDecodeErrorZ {
+typedef struct LDKCResult_NoneLightningErrorZ {
    /**
-    * The contents of this CResult_FundingLockedDecodeErrorZ, accessible via either
+    * The contents of this CResult_NoneLightningErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_FundingLockedDecodeErrorZPtr contents;
+   union LDKCResult_NoneLightningErrorZPtr contents;
    /**
-    * Whether this CResult_FundingLockedDecodeErrorZ represents a success state.
+    * Whether this CResult_NoneLightningErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_FundingLockedDecodeErrorZ;
+} 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;
 
 
 
 /**
- * An init message to be sent or received from a peer
+ * 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 LDKInit {
+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.
     */
-   LDKnativeInit *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;
-} LDKInit;
+} LDKPeerHandleError;
 
 /**
- * The contents of CResult_InitDecodeErrorZ
+ * The contents of CResult_CVec_u8ZPeerHandleErrorZ
  */
-typedef union LDKCResult_InitDecodeErrorZPtr {
+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 LDKInit *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_InitDecodeErrorZPtr;
+   struct LDKPeerHandleError *err;
+} LDKCResult_CVec_u8ZPeerHandleErrorZPtr;
 
 /**
- * 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_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_InitDecodeErrorZ {
+typedef struct LDKCResult_CVec_u8ZPeerHandleErrorZ {
    /**
-    * The contents of this CResult_InitDecodeErrorZ, 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_InitDecodeErrorZPtr contents;
+   union LDKCResult_CVec_u8ZPeerHandleErrorZPtr contents;
    /**
-    * Whether this CResult_InitDecodeErrorZ represents a success state.
+    * Whether this CResult_CVec_u8ZPeerHandleErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_InitDecodeErrorZ;
+} LDKCResult_CVec_u8ZPeerHandleErrorZ;
 
 /**
- * The contents of CResult_OpenChannelDecodeErrorZ
+ * The contents of CResult_NonePeerHandleErrorZ
  */
-typedef union LDKCResult_OpenChannelDecodeErrorZPtr {
+typedef union LDKCResult_NonePeerHandleErrorZPtr {
    /**
-    * 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 LDKOpenChannel *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_OpenChannelDecodeErrorZPtr;
+   struct LDKPeerHandleError *err;
+} LDKCResult_NonePeerHandleErrorZPtr;
 
 /**
- * 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_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_OpenChannelDecodeErrorZ {
+typedef struct LDKCResult_NonePeerHandleErrorZ {
    /**
-    * The contents of this CResult_OpenChannelDecodeErrorZ, accessible via either
+    * The contents of this CResult_NonePeerHandleErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_OpenChannelDecodeErrorZPtr contents;
+   union LDKCResult_NonePeerHandleErrorZPtr contents;
    /**
-    * Whether this CResult_OpenChannelDecodeErrorZ represents a success state.
+    * Whether this CResult_NonePeerHandleErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_OpenChannelDecodeErrorZ;
+} LDKCResult_NonePeerHandleErrorZ;
 
 /**
- * The contents of CResult_RevokeAndACKDecodeErrorZ
+ * The contents of CResult_boolPeerHandleErrorZ
  */
-typedef union LDKCResult_RevokeAndACKDecodeErrorZPtr {
+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 LDKRevokeAndACK *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_RevokeAndACKDecodeErrorZPtr;
+   struct LDKPeerHandleError *err;
+} LDKCResult_boolPeerHandleErrorZPtr;
 
 /**
- * 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_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_RevokeAndACKDecodeErrorZ {
+typedef struct LDKCResult_boolPeerHandleErrorZ {
    /**
-    * The contents of this CResult_RevokeAndACKDecodeErrorZ, accessible via either
+    * The contents of this CResult_boolPeerHandleErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_RevokeAndACKDecodeErrorZPtr contents;
+   union LDKCResult_boolPeerHandleErrorZPtr contents;
    /**
-    * Whether this CResult_RevokeAndACKDecodeErrorZ represents a success state.
+    * Whether this CResult_boolPeerHandleErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_RevokeAndACKDecodeErrorZ;
+} LDKCResult_boolPeerHandleErrorZ;
+
+
 
 /**
- * The contents of CResult_ShutdownDecodeErrorZ
+ * Details about one direction of a channel. Received
+ * within a channel update.
  */
-typedef union LDKCResult_ShutdownDecodeErrorZPtr {
+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.
+    */
+   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;
+} LDKDirectionalChannelInfo;
+
+/**
+ * The contents of CResult_DirectionalChannelInfoDecodeErrorZ
+ */
+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 LDKShutdown *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_ShutdownDecodeErrorZPtr;
+} LDKCResult_DirectionalChannelInfoDecodeErrorZPtr;
 
 /**
- * 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_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_ShutdownDecodeErrorZ {
+typedef struct LDKCResult_DirectionalChannelInfoDecodeErrorZ {
    /**
-    * The contents of this CResult_ShutdownDecodeErrorZ, accessible via either
+    * The contents of this CResult_DirectionalChannelInfoDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_ShutdownDecodeErrorZPtr contents;
+   union LDKCResult_DirectionalChannelInfoDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_ShutdownDecodeErrorZ represents a success state.
+    * Whether this CResult_DirectionalChannelInfoDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_ShutdownDecodeErrorZ;
+} LDKCResult_DirectionalChannelInfoDecodeErrorZ;
+
+
 
 /**
- * The contents of CResult_UpdateFailHTLCDecodeErrorZ
+ * Details about a channel (both directions).
+ * Received within a channel announcement.
  */
-typedef union LDKCResult_UpdateFailHTLCDecodeErrorZPtr {
+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.
+    */
+   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;
+} LDKChannelInfo;
+
+/**
+ * The contents of CResult_ChannelInfoDecodeErrorZ
+ */
+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 LDKUpdateFailHTLC *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_UpdateFailHTLCDecodeErrorZPtr;
+} LDKCResult_ChannelInfoDecodeErrorZPtr;
 
 /**
- * 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.
+ * 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_UpdateFailHTLCDecodeErrorZ {
+typedef struct LDKCResult_ChannelInfoDecodeErrorZ {
    /**
-    * The contents of this CResult_UpdateFailHTLCDecodeErrorZ, accessible via either
+    * The contents of this CResult_ChannelInfoDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_UpdateFailHTLCDecodeErrorZPtr contents;
+   union LDKCResult_ChannelInfoDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_UpdateFailHTLCDecodeErrorZ represents a success state.
+    * Whether this CResult_ChannelInfoDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_UpdateFailHTLCDecodeErrorZ;
+} LDKCResult_ChannelInfoDecodeErrorZ;
+
+
 
 /**
- * The contents of CResult_UpdateFailMalformedHTLCDecodeErrorZ
+ * Fees for routing via a given channel or a node
  */
-typedef union LDKCResult_UpdateFailMalformedHTLCDecodeErrorZPtr {
+typedef struct MUST_USE_STRUCT LDKRoutingFees {
+   /**
+    * 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.
+    */
+   LDKnativeRoutingFees *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;
+} LDKRoutingFees;
+
+/**
+ * The contents of CResult_RoutingFeesDecodeErrorZ
+ */
+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 LDKUpdateFailMalformedHTLC *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_UpdateFailMalformedHTLCDecodeErrorZPtr;
+} LDKCResult_RoutingFeesDecodeErrorZPtr;
 
 /**
- * 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.
+ * 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_UpdateFailMalformedHTLCDecodeErrorZ {
+typedef struct LDKCResult_RoutingFeesDecodeErrorZ {
    /**
-    * The contents of this CResult_UpdateFailMalformedHTLCDecodeErrorZ, accessible via either
+    * The contents of this CResult_RoutingFeesDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_UpdateFailMalformedHTLCDecodeErrorZPtr contents;
+   union LDKCResult_RoutingFeesDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_UpdateFailMalformedHTLCDecodeErrorZ represents a success state.
+    * Whether this CResult_RoutingFeesDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ;
+} LDKCResult_RoutingFeesDecodeErrorZ;
 
 
 
 /**
- * An update_fee message to be sent or received from a peer
+ * Information received in the latest node_announcement from this node.
  */
-typedef struct MUST_USE_STRUCT LDKUpdateFee {
+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.
     */
-   LDKnativeUpdateFee *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;
-} LDKUpdateFee;
+} LDKNodeAnnouncementInfo;
 
 /**
- * The contents of CResult_UpdateFeeDecodeErrorZ
+ * The contents of CResult_NodeAnnouncementInfoDecodeErrorZ
  */
-typedef union LDKCResult_UpdateFeeDecodeErrorZPtr {
+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 LDKUpdateFee *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_UpdateFeeDecodeErrorZPtr;
+} LDKCResult_NodeAnnouncementInfoDecodeErrorZPtr;
 
 /**
- * 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.
+ * 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_UpdateFeeDecodeErrorZ {
+typedef struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ {
    /**
-    * The contents of this CResult_UpdateFeeDecodeErrorZ, accessible via either
+    * The contents of this CResult_NodeAnnouncementInfoDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_UpdateFeeDecodeErrorZPtr contents;
+   union LDKCResult_NodeAnnouncementInfoDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_UpdateFeeDecodeErrorZ represents a success state.
+    * Whether this CResult_NodeAnnouncementInfoDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_UpdateFeeDecodeErrorZ;
+} LDKCResult_NodeAnnouncementInfoDecodeErrorZ;
 
 /**
- * The contents of CResult_UpdateFulfillHTLCDecodeErrorZ
+ * A dynamically-allocated array of u64s of arbitrary size.
+ * This corresponds to std::vector in C++
  */
-typedef union LDKCResult_UpdateFulfillHTLCDecodeErrorZPtr {
+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 LDKUpdateFulfillHTLC *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_UpdateFulfillHTLCDecodeErrorZPtr;
+   uintptr_t datalen;
+} LDKCVec_u64Z;
+
+
 
 /**
- * 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`.
+ * Details about a node in the network, known from the network announcement.
  */
-typedef struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ {
+typedef struct MUST_USE_STRUCT LDKNodeInfo {
    /**
-    * The contents of this CResult_UpdateFulfillHTLCDecodeErrorZ, 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_UpdateFulfillHTLCDecodeErrorZPtr contents;
+   LDKnativeNodeInfo *inner;
    /**
-    * Whether this CResult_UpdateFulfillHTLCDecodeErrorZ 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_UpdateFulfillHTLCDecodeErrorZ;
+   bool is_owned;
+} LDKNodeInfo;
 
 /**
- * The contents of CResult_UpdateAddHTLCDecodeErrorZ
+ * The contents of CResult_NodeInfoDecodeErrorZ
  */
-typedef union LDKCResult_UpdateAddHTLCDecodeErrorZPtr {
+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 LDKUpdateAddHTLC *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_UpdateAddHTLCDecodeErrorZPtr;
+} LDKCResult_NodeInfoDecodeErrorZPtr;
 
 /**
- * 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_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_UpdateAddHTLCDecodeErrorZ {
+typedef struct LDKCResult_NodeInfoDecodeErrorZ {
    /**
-    * The contents of this CResult_UpdateAddHTLCDecodeErrorZ, accessible via either
+    * The contents of this CResult_NodeInfoDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_UpdateAddHTLCDecodeErrorZPtr contents;
+   union LDKCResult_NodeInfoDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_UpdateAddHTLCDecodeErrorZ represents a success state.
+    * Whether this CResult_NodeInfoDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_UpdateAddHTLCDecodeErrorZ;
+} LDKCResult_NodeInfoDecodeErrorZ;
 
 
 
 /**
- * A ping message to be sent or received from a peer
+ * Represents the network as nodes and channels between them
  */
-typedef struct MUST_USE_STRUCT LDKPing {
+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.
     */
-   LDKnativePing *inner;
+   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;
-} LDKPing;
+} LDKNetworkGraph;
 
 /**
- * The contents of CResult_PingDecodeErrorZ
+ * The contents of CResult_NetworkGraphDecodeErrorZ
  */
-typedef union LDKCResult_PingDecodeErrorZPtr {
+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 LDKPing *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_PingDecodeErrorZPtr;
+} LDKCResult_NetworkGraphDecodeErrorZPtr;
 
 /**
- * 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_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_PingDecodeErrorZ {
+typedef struct LDKCResult_NetworkGraphDecodeErrorZ {
    /**
-    * The contents of this CResult_PingDecodeErrorZ, accessible via either
+    * The contents of this CResult_NetworkGraphDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_PingDecodeErrorZPtr contents;
+   union LDKCResult_NetworkGraphDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_PingDecodeErrorZ represents a success state.
+    * Whether this CResult_NetworkGraphDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_PingDecodeErrorZ;
-
+} LDKCResult_NetworkGraphDecodeErrorZ;
 
+/**
+ * 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 pong message to be sent or received from a peer
+ * 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 MUST_USE_STRUCT LDKPong {
+typedef struct LDKCResult_NetAddressu8Z {
    /**
-    * 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_NetAddressu8Z, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   LDKnativePong *inner;
+   union LDKCResult_NetAddressu8ZPtr 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_NetAddressu8Z represents a success state.
     */
-   bool is_owned;
-} LDKPong;
+   bool result_ok;
+} LDKCResult_NetAddressu8Z;
 
 /**
- * The contents of CResult_PongDecodeErrorZ
+ * The contents of CResult_CResult_NetAddressu8ZDecodeErrorZ
  */
-typedef union LDKCResult_PongDecodeErrorZPtr {
+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 LDKPong *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_PongDecodeErrorZPtr;
+} LDKCResult_CResult_NetAddressu8ZDecodeErrorZPtr;
 
 /**
- * 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_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_PongDecodeErrorZ {
+typedef struct LDKCResult_CResult_NetAddressu8ZDecodeErrorZ {
    /**
-    * The contents of this CResult_PongDecodeErrorZ, 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_PongDecodeErrorZPtr contents;
+   union LDKCResult_CResult_NetAddressu8ZDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_PongDecodeErrorZ represents a success state.
+    * Whether this CResult_CResult_NetAddressu8ZDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_PongDecodeErrorZ;
+} LDKCResult_CResult_NetAddressu8ZDecodeErrorZ;
 
 /**
- * The contents of CResult_UnsignedChannelAnnouncementDecodeErrorZ
+ * The contents of CResult_NetAddressDecodeErrorZ
  */
-typedef union LDKCResult_UnsignedChannelAnnouncementDecodeErrorZPtr {
+typedef union LDKCResult_NetAddressDecodeErrorZPtr {
    /**
     * 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 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_UnsignedChannelAnnouncementDecodeErrorZPtr;
+} LDKCResult_NetAddressDecodeErrorZPtr;
 
 /**
- * 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_NetAddressDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::ln::msgs::NetAddress 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_NetAddressDecodeErrorZ {
    /**
-    * The contents of this CResult_UnsignedChannelAnnouncementDecodeErrorZ, accessible via either
+    * The contents of this CResult_NetAddressDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_UnsignedChannelAnnouncementDecodeErrorZPtr contents;
+   union LDKCResult_NetAddressDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_UnsignedChannelAnnouncementDecodeErrorZ represents a success state.
+    * Whether this CResult_NetAddressDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ;
+} LDKCResult_NetAddressDecodeErrorZ;
+
+
 
 /**
- * The contents of CResult_ChannelAnnouncementDecodeErrorZ
+ * An update_add_htlc message to be sent or received from a peer
  */
-typedef union LDKCResult_ChannelAnnouncementDecodeErrorZPtr {
+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 LDKChannelAnnouncement *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_ChannelAnnouncementDecodeErrorZPtr;
+   bool is_owned;
+} LDKUpdateAddHTLC;
 
 /**
- * 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`.
+ * A dynamically-allocated array of crate::lightning::ln::msgs::UpdateAddHTLCs of arbitrary size.
+ * This corresponds to std::vector in C++
  */
-typedef struct LDKCResult_ChannelAnnouncementDecodeErrorZ {
+typedef struct LDKCVec_UpdateAddHTLCZ {
    /**
-    * The contents of this CResult_ChannelAnnouncementDecodeErrorZ, 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_ChannelAnnouncementDecodeErrorZPtr contents;
+   struct LDKUpdateAddHTLC *data;
    /**
-    * Whether this CResult_ChannelAnnouncementDecodeErrorZ represents a success state.
+    * The number of elements pointed to by `data`.
     */
-   bool result_ok;
-} LDKCResult_ChannelAnnouncementDecodeErrorZ;
+   uintptr_t datalen;
+} LDKCVec_UpdateAddHTLCZ;
 
 
 
 /**
- * The unsigned part of a channel_update
+ * An update_fulfill_htlc message to be sent or received from a peer
  */
-typedef struct MUST_USE_STRUCT LDKUnsignedChannelUpdate {
+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.
     */
-   LDKnativeUnsignedChannelUpdate *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;
-} LDKUnsignedChannelUpdate;
+} LDKUpdateFulfillHTLC;
 
 /**
- * The contents of CResult_UnsignedChannelUpdateDecodeErrorZ
+ * A dynamically-allocated array of crate::lightning::ln::msgs::UpdateFulfillHTLCs of arbitrary size.
+ * This corresponds to std::vector in C++
  */
-typedef union LDKCResult_UnsignedChannelUpdateDecodeErrorZPtr {
+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 LDKUnsignedChannelUpdate *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_UnsignedChannelUpdateDecodeErrorZPtr;
+   uintptr_t datalen;
+} LDKCVec_UpdateFulfillHTLCZ;
+
+
 
 /**
- * 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`.
+ * An update_fail_htlc message to be sent or received from a peer
  */
-typedef struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ {
+typedef struct MUST_USE_STRUCT LDKUpdateFailHTLC {
    /**
-    * The contents of this CResult_UnsignedChannelUpdateDecodeErrorZ, 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_UnsignedChannelUpdateDecodeErrorZPtr contents;
+   LDKnativeUpdateFailHTLC *inner;
    /**
-    * Whether this CResult_UnsignedChannelUpdateDecodeErrorZ 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_UnsignedChannelUpdateDecodeErrorZ;
+   bool is_owned;
+} LDKUpdateFailHTLC;
+
+/**
+ * A dynamically-allocated array of crate::lightning::ln::msgs::UpdateFailHTLCs of arbitrary size.
+ * This corresponds to std::vector in C++
+ */
+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;
+
+
 
 /**
- * The contents of CResult_ChannelUpdateDecodeErrorZ
+ * An update_fail_malformed_htlc message to be sent or received from a peer
  */
-typedef union LDKCResult_ChannelUpdateDecodeErrorZPtr {
+typedef struct MUST_USE_STRUCT LDKUpdateFailMalformedHTLC {
    /**
-    * 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 LDKChannelUpdate *result;
+   LDKnativeUpdateFailMalformedHTLC *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_ChannelUpdateDecodeErrorZPtr;
+   bool is_owned;
+} LDKUpdateFailMalformedHTLC;
 
 /**
- * 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`.
+ * A dynamically-allocated array of crate::lightning::ln::msgs::UpdateFailMalformedHTLCs of arbitrary size.
+ * This corresponds to std::vector in C++
  */
-typedef struct LDKCResult_ChannelUpdateDecodeErrorZ {
+typedef struct LDKCVec_UpdateFailMalformedHTLCZ {
    /**
-    * The contents of this CResult_ChannelUpdateDecodeErrorZ, 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_ChannelUpdateDecodeErrorZPtr contents;
+   struct LDKUpdateFailMalformedHTLC *data;
    /**
-    * Whether this CResult_ChannelUpdateDecodeErrorZ represents a success state.
+    * The number of elements pointed to by `data`.
     */
-   bool result_ok;
-} LDKCResult_ChannelUpdateDecodeErrorZ;
+   uintptr_t datalen;
+} LDKCVec_UpdateFailMalformedHTLCZ;
 
 /**
- * The contents of CResult_ErrorMessageDecodeErrorZ
+ * The contents of CResult_AcceptChannelDecodeErrorZ
  */
-typedef union LDKCResult_ErrorMessageDecodeErrorZPtr {
+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 LDKErrorMessage *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_ErrorMessageDecodeErrorZPtr;
+} LDKCResult_AcceptChannelDecodeErrorZPtr;
 
 /**
- * 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_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_ErrorMessageDecodeErrorZ {
+typedef struct LDKCResult_AcceptChannelDecodeErrorZ {
    /**
-    * The contents of this CResult_ErrorMessageDecodeErrorZ, accessible via either
+    * The contents of this CResult_AcceptChannelDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_ErrorMessageDecodeErrorZPtr contents;
+   union LDKCResult_AcceptChannelDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_ErrorMessageDecodeErrorZ represents a success state.
+    * Whether this CResult_AcceptChannelDecodeErrorZ 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_AcceptChannelDecodeErrorZ;
 
 /**
- * The contents of CResult_UnsignedNodeAnnouncementDecodeErrorZ
+ * The contents of CResult_AnnouncementSignaturesDecodeErrorZ
  */
-typedef union LDKCResult_UnsignedNodeAnnouncementDecodeErrorZPtr {
+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 LDKUnsignedNodeAnnouncement *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_UnsignedNodeAnnouncementDecodeErrorZPtr;
+} LDKCResult_AnnouncementSignaturesDecodeErrorZPtr;
 
 /**
- * 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_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_UnsignedNodeAnnouncementDecodeErrorZ {
+typedef struct LDKCResult_AnnouncementSignaturesDecodeErrorZ {
    /**
-    * The contents of this CResult_UnsignedNodeAnnouncementDecodeErrorZ, accessible via either
+    * The contents of this CResult_AnnouncementSignaturesDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_UnsignedNodeAnnouncementDecodeErrorZPtr contents;
+   union LDKCResult_AnnouncementSignaturesDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_UnsignedNodeAnnouncementDecodeErrorZ represents a success state.
+    * Whether this CResult_AnnouncementSignaturesDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ;
+} LDKCResult_AnnouncementSignaturesDecodeErrorZ;
 
 /**
- * The contents of CResult_NodeAnnouncementDecodeErrorZ
+ * The contents of CResult_ChannelReestablishDecodeErrorZ
  */
-typedef union LDKCResult_NodeAnnouncementDecodeErrorZPtr {
+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 LDKNodeAnnouncement *result;
+   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_NodeAnnouncementDecodeErrorZPtr;
+} LDKCResult_ChannelReestablishDecodeErrorZPtr;
 
 /**
- * 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_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 LDKCResult_NodeAnnouncementDecodeErrorZ {
+typedef struct LDKCResult_ChannelReestablishDecodeErrorZ {
    /**
-    * The contents of this CResult_NodeAnnouncementDecodeErrorZ, accessible via either
+    * The contents of this CResult_ChannelReestablishDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_NodeAnnouncementDecodeErrorZPtr contents;
+   union LDKCResult_ChannelReestablishDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_NodeAnnouncementDecodeErrorZ represents a success state.
+    * Whether this CResult_ChannelReestablishDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_NodeAnnouncementDecodeErrorZ;
+} LDKCResult_ChannelReestablishDecodeErrorZ;
 
 /**
- * The contents of CResult_QueryShortChannelIdsDecodeErrorZ
+ * The contents of CResult_ClosingSignedDecodeErrorZ
  */
-typedef union LDKCResult_QueryShortChannelIdsDecodeErrorZPtr {
+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 LDKQueryShortChannelIds *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_QueryShortChannelIdsDecodeErrorZPtr;
+} LDKCResult_ClosingSignedDecodeErrorZPtr;
 
 /**
- * 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_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_QueryShortChannelIdsDecodeErrorZ {
+typedef struct LDKCResult_ClosingSignedDecodeErrorZ {
    /**
-    * The contents of this CResult_QueryShortChannelIdsDecodeErrorZ, accessible via either
+    * The contents of this CResult_ClosingSignedDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_QueryShortChannelIdsDecodeErrorZPtr contents;
+   union LDKCResult_ClosingSignedDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_QueryShortChannelIdsDecodeErrorZ represents a success state.
+    * Whether this CResult_ClosingSignedDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_QueryShortChannelIdsDecodeErrorZ;
+} LDKCResult_ClosingSignedDecodeErrorZ;
 
 
 
 /**
- * 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.
+ * A commitment_signed message to be sent or received from a peer
  */
-typedef struct MUST_USE_STRUCT LDKReplyShortChannelIdsEnd {
+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.
     */
-   LDKnativeReplyShortChannelIdsEnd *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;
-} LDKReplyShortChannelIdsEnd;
-
-/**
- * The contents of CResult_ReplyShortChannelIdsEndDecodeErrorZ
- */
-typedef union LDKCResult_ReplyShortChannelIdsEndDecodeErrorZPtr {
-   /**
-    * A pointer to the contents in the success state.
-    * Reading from this pointer when `result_ok` is not set is undefined.
-    */
-   struct LDKReplyShortChannelIdsEnd *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;
-
-/**
- * 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_ReplyShortChannelIdsEndDecodeErrorZ {
-   /**
-    * The contents of this CResult_ReplyShortChannelIdsEndDecodeErrorZ, accessible via either
-    * `err` or `result` depending on the state of `result_ok`.
-    */
-   union LDKCResult_ReplyShortChannelIdsEndDecodeErrorZPtr contents;
-   /**
-    * Whether this CResult_ReplyShortChannelIdsEndDecodeErrorZ represents a success state.
-    */
-   bool result_ok;
-} LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ;
+} LDKCommitmentSigned;
 
 /**
- * The contents of CResult_QueryChannelRangeDecodeErrorZ
+ * The contents of CResult_CommitmentSignedDecodeErrorZ
  */
-typedef union LDKCResult_QueryChannelRangeDecodeErrorZPtr {
+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 LDKQueryChannelRange *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_QueryChannelRangeDecodeErrorZPtr;
+} LDKCResult_CommitmentSignedDecodeErrorZPtr;
 
 /**
- * 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_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_QueryChannelRangeDecodeErrorZ {
+typedef struct LDKCResult_CommitmentSignedDecodeErrorZ {
    /**
-    * The contents of this CResult_QueryChannelRangeDecodeErrorZ, accessible via either
+    * The contents of this CResult_CommitmentSignedDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_QueryChannelRangeDecodeErrorZPtr contents;
+   union LDKCResult_CommitmentSignedDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_QueryChannelRangeDecodeErrorZ represents a success state.
+    * Whether this CResult_CommitmentSignedDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_QueryChannelRangeDecodeErrorZ;
+} LDKCResult_CommitmentSignedDecodeErrorZ;
 
 /**
- * The contents of CResult_ReplyChannelRangeDecodeErrorZ
+ * The contents of CResult_FundingCreatedDecodeErrorZ
  */
-typedef union LDKCResult_ReplyChannelRangeDecodeErrorZPtr {
+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 LDKReplyChannelRange *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_ReplyChannelRangeDecodeErrorZPtr;
+} LDKCResult_FundingCreatedDecodeErrorZPtr;
 
 /**
- * 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_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_ReplyChannelRangeDecodeErrorZ {
+typedef struct LDKCResult_FundingCreatedDecodeErrorZ {
    /**
-    * The contents of this CResult_ReplyChannelRangeDecodeErrorZ, accessible via either
+    * The contents of this CResult_FundingCreatedDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_ReplyChannelRangeDecodeErrorZPtr contents;
-   /**
-    * Whether this CResult_ReplyChannelRangeDecodeErrorZ represents a success state.
-    */
-   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 {
-   /**
-    * 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;
+   union LDKCResult_FundingCreatedDecodeErrorZPtr 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_FundingCreatedDecodeErrorZ represents a success state.
     */
-   bool is_owned;
-} LDKGossipTimestampFilter;
+   bool result_ok;
+} LDKCResult_FundingCreatedDecodeErrorZ;
 
 /**
- * The contents of CResult_GossipTimestampFilterDecodeErrorZ
+ * The contents of CResult_FundingSignedDecodeErrorZ
  */
-typedef union LDKCResult_GossipTimestampFilterDecodeErrorZPtr {
+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 LDKGossipTimestampFilter *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_GossipTimestampFilterDecodeErrorZPtr;
+} LDKCResult_FundingSignedDecodeErrorZPtr;
 
 /**
- * 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_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_GossipTimestampFilterDecodeErrorZ {
+typedef struct LDKCResult_FundingSignedDecodeErrorZ {
    /**
-    * The contents of this CResult_GossipTimestampFilterDecodeErrorZ, accessible via either
+    * The contents of this CResult_FundingSignedDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_GossipTimestampFilterDecodeErrorZPtr contents;
+   union LDKCResult_FundingSignedDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_GossipTimestampFilterDecodeErrorZ represents a success state.
+    * Whether this CResult_FundingSignedDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_GossipTimestampFilterDecodeErrorZ;
-
-/**
- * When signing using a fallible method either an user-supplied `SignError` or a `CreationError`
- * may occur.
- */
-typedef enum LDKSignOrCreationError_Tag {
-   /**
-    * An error occurred during signing
-    */
-   LDKSignOrCreationError_SignError,
-   /**
-    * An error occurred while building the transaction
-    */
-   LDKSignOrCreationError_CreationError,
-   /**
-    * Must be last for serialization purposes
-    */
-   LDKSignOrCreationError_Sentinel,
-} LDKSignOrCreationError_Tag;
-
-typedef struct MUST_USE_STRUCT LDKSignOrCreationError {
-   LDKSignOrCreationError_Tag tag;
-   union {
-      struct {
-         enum LDKCreationError creation_error;
-      };
-   };
-} LDKSignOrCreationError;
+} LDKCResult_FundingSignedDecodeErrorZ;
 
 /**
- * The contents of CResult_InvoiceSignOrCreationErrorZ
+ * The contents of CResult_FundingLockedDecodeErrorZ
  */
-typedef union LDKCResult_InvoiceSignOrCreationErrorZPtr {
+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 LDKInvoice *result;
+   struct LDKFundingLocked *result;
    /**
     * A pointer to the contents in the error state.
     * Reading from this pointer when `result_ok` is set is undefined.
     */
-   struct LDKSignOrCreationError *err;
-} LDKCResult_InvoiceSignOrCreationErrorZPtr;
+   struct LDKDecodeError *err;
+} LDKCResult_FundingLockedDecodeErrorZPtr;
 
 /**
- * A CResult_InvoiceSignOrCreationErrorZ represents the result of a fallible operation,
- * containing a crate::lightning_invoice::Invoice on success and a crate::lightning_invoice::SignOrCreationError on failure.
+ * 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_InvoiceSignOrCreationErrorZ {
+typedef struct LDKCResult_FundingLockedDecodeErrorZ {
    /**
-    * The contents of this CResult_InvoiceSignOrCreationErrorZ, accessible via either
+    * The contents of this CResult_FundingLockedDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_InvoiceSignOrCreationErrorZPtr contents;
+   union LDKCResult_FundingLockedDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_InvoiceSignOrCreationErrorZ represents a success state.
+    * Whether this CResult_FundingLockedDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_InvoiceSignOrCreationErrorZ;
+} LDKCResult_FundingLockedDecodeErrorZ;
+
+
 
 /**
- * The contents of CResult_DelayedPaymentOutputDescriptorDecodeErrorZ
+ * An init message to be sent or received from a peer
  */
-typedef union LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZPtr {
+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.
+    */
+   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;
+} LDKInit;
+
+/**
+ * The contents of CResult_InitDecodeErrorZ
+ */
+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 LDKDelayedPaymentOutputDescriptor *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_DelayedPaymentOutputDescriptorDecodeErrorZPtr;
+} LDKCResult_InitDecodeErrorZPtr;
 
 /**
- * A CResult_DelayedPaymentOutputDescriptorDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::chain::keysinterface::DelayedPaymentOutputDescriptor 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_DelayedPaymentOutputDescriptorDecodeErrorZ {
+typedef struct LDKCResult_InitDecodeErrorZ {
    /**
-    * The contents of this CResult_DelayedPaymentOutputDescriptorDecodeErrorZ, accessible via either
+    * The contents of this CResult_InitDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZPtr contents;
+   union LDKCResult_InitDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_DelayedPaymentOutputDescriptorDecodeErrorZ represents a success state.
+    * Whether this CResult_InitDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ;
+} LDKCResult_InitDecodeErrorZ;
 
 /**
- * The contents of CResult_StaticPaymentOutputDescriptorDecodeErrorZ
+ * The contents of CResult_OpenChannelDecodeErrorZ
  */
-typedef union LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZPtr {
+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 LDKStaticPaymentOutputDescriptor *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_StaticPaymentOutputDescriptorDecodeErrorZPtr;
+} LDKCResult_OpenChannelDecodeErrorZPtr;
 
 /**
- * A CResult_StaticPaymentOutputDescriptorDecodeErrorZ represents the result of a fallible operation,
- * containing a crate::lightning::chain::keysinterface::StaticPaymentOutputDescriptor 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_StaticPaymentOutputDescriptorDecodeErrorZ {
+typedef struct LDKCResult_OpenChannelDecodeErrorZ {
    /**
-    * The contents of this CResult_StaticPaymentOutputDescriptorDecodeErrorZ, accessible via either
+    * The contents of this CResult_OpenChannelDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZPtr contents;
+   union LDKCResult_OpenChannelDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_StaticPaymentOutputDescriptorDecodeErrorZ represents a success state.
+    * Whether this CResult_OpenChannelDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ;
+} LDKCResult_OpenChannelDecodeErrorZ;
 
 /**
- * The contents of CResult_SpendableOutputDescriptorDecodeErrorZ
+ * The contents of CResult_RevokeAndACKDecodeErrorZ
  */
-typedef union LDKCResult_SpendableOutputDescriptorDecodeErrorZPtr {
+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 LDKSpendableOutputDescriptor *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_SpendableOutputDescriptorDecodeErrorZPtr;
+} LDKCResult_RevokeAndACKDecodeErrorZPtr;
 
 /**
- * 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_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_SpendableOutputDescriptorDecodeErrorZ {
+typedef struct LDKCResult_RevokeAndACKDecodeErrorZ {
    /**
-    * The contents of this CResult_SpendableOutputDescriptorDecodeErrorZ, accessible via either
+    * The contents of this CResult_RevokeAndACKDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_SpendableOutputDescriptorDecodeErrorZPtr contents;
+   union LDKCResult_RevokeAndACKDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_SpendableOutputDescriptorDecodeErrorZ represents a success state.
+    * Whether this CResult_RevokeAndACKDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_SpendableOutputDescriptorDecodeErrorZ;
+} LDKCResult_RevokeAndACKDecodeErrorZ;
 
 /**
- * The contents of CResult_SignDecodeErrorZ
+ * The contents of CResult_ShutdownDecodeErrorZ
  */
-typedef union LDKCResult_SignDecodeErrorZPtr {
+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 LDKSign *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_SignDecodeErrorZPtr;
+} LDKCResult_ShutdownDecodeErrorZPtr;
 
 /**
- * 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_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_SignDecodeErrorZ {
+typedef struct LDKCResult_ShutdownDecodeErrorZ {
    /**
-    * The contents of this CResult_SignDecodeErrorZ, accessible via either
+    * The contents of this CResult_ShutdownDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_SignDecodeErrorZPtr contents;
+   union LDKCResult_ShutdownDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_SignDecodeErrorZ represents a success state.
+    * Whether this CResult_ShutdownDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_SignDecodeErrorZ;
-
-/**
- * Represents a secp256k1 signature serialized as two 32-byte numbers as well as a tag which
- * allows recovering the exact public key which created the signature given the message.
- */
-typedef struct LDKRecoverableSignature {
-   /**
-    * The bytes of the signature in "compact" form plus a "Recovery ID" which allows for
-    * recovery.
-    */
-   uint8_t serialized_form[68];
-} LDKRecoverableSignature;
+} LDKCResult_ShutdownDecodeErrorZ;
 
 /**
- * The contents of CResult_RecoverableSignatureNoneZ
+ * The contents of CResult_UpdateFailHTLCDecodeErrorZ
  */
-typedef union LDKCResult_RecoverableSignatureNoneZPtr {
+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 LDKRecoverableSignature *result;
+   struct LDKUpdateFailHTLC *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_RecoverableSignatureNoneZPtr;
+   struct LDKDecodeError *err;
+} LDKCResult_UpdateFailHTLCDecodeErrorZPtr;
 
 /**
- * A CResult_RecoverableSignatureNoneZ represents the result of a fallible operation,
- * containing a crate::c_types::RecoverableSignature on success and a () 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_RecoverableSignatureNoneZ {
+typedef struct LDKCResult_UpdateFailHTLCDecodeErrorZ {
    /**
-    * The contents of this CResult_RecoverableSignatureNoneZ, accessible via either
+    * The contents of this CResult_UpdateFailHTLCDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_RecoverableSignatureNoneZPtr contents;
+   union LDKCResult_UpdateFailHTLCDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_RecoverableSignatureNoneZ represents a success state.
+    * Whether this CResult_UpdateFailHTLCDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_RecoverableSignatureNoneZ;
-
-/**
- * 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_UpdateFailHTLCDecodeErrorZ;
 
 /**
- * The contents of CResult_CVec_CVec_u8ZZNoneZ
+ * The contents of CResult_UpdateFailMalformedHTLCDecodeErrorZ
  */
-typedef union LDKCResult_CVec_CVec_u8ZZNoneZPtr {
+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 LDKCVec_CVec_u8ZZ *result;
+   struct LDKUpdateFailMalformedHTLC *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_UpdateFailMalformedHTLCDecodeErrorZPtr;
 
 /**
- * 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_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_CVec_CVec_u8ZZNoneZ {
+typedef struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ {
    /**
-    * The contents of this CResult_CVec_CVec_u8ZZNoneZ, accessible via either
+    * The contents of this CResult_UpdateFailMalformedHTLCDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_CVec_CVec_u8ZZNoneZPtr contents;
+   union LDKCResult_UpdateFailMalformedHTLCDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_CVec_CVec_u8ZZNoneZ represents a success state.
+    * Whether this CResult_UpdateFailMalformedHTLCDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_CVec_CVec_u8ZZNoneZ;
+} LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ;
 
 
 
 /**
- * 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.
+ * An update_fee message to be sent or received from a peer
  */
-typedef struct MUST_USE_STRUCT LDKInMemorySigner {
+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.
     */
-   LDKnativeInMemorySigner *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;
-} LDKInMemorySigner;
+} LDKUpdateFee;
 
 /**
- * The contents of CResult_InMemorySignerDecodeErrorZ
+ * The contents of CResult_UpdateFeeDecodeErrorZ
  */
-typedef union LDKCResult_InMemorySignerDecodeErrorZPtr {
+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 LDKInMemorySigner *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_InMemorySignerDecodeErrorZPtr;
+} LDKCResult_UpdateFeeDecodeErrorZPtr;
 
 /**
- * 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_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_InMemorySignerDecodeErrorZ {
+typedef struct LDKCResult_UpdateFeeDecodeErrorZ {
    /**
-    * The contents of this CResult_InMemorySignerDecodeErrorZ, accessible via either
+    * The contents of this CResult_UpdateFeeDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_InMemorySignerDecodeErrorZPtr contents;
+   union LDKCResult_UpdateFeeDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_InMemorySignerDecodeErrorZ represents a success state.
+    * Whether this CResult_UpdateFeeDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_InMemorySignerDecodeErrorZ;
+} LDKCResult_UpdateFeeDecodeErrorZ;
 
 /**
- * A dynamically-allocated array of crate::c_types::TxOuts of arbitrary size.
- * This corresponds to std::vector in C++
+ * The contents of CResult_UpdateFulfillHTLCDecodeErrorZ
  */
-typedef struct LDKCVec_TxOutZ {
+typedef union LDKCResult_UpdateFulfillHTLCDecodeErrorZPtr {
    /**
-    * 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 LDKTxOut *data;
+   struct LDKUpdateFulfillHTLC *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_TxOutZ;
+   struct LDKDecodeError *err;
+} LDKCResult_UpdateFulfillHTLCDecodeErrorZPtr;
 
 /**
- * The contents of CResult_TransactionNoneZ
+ * 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 union LDKCResult_TransactionNoneZPtr {
+typedef struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ {
+   /**
+    * The contents of this CResult_UpdateFulfillHTLCDecodeErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
+    */
+   union LDKCResult_UpdateFulfillHTLCDecodeErrorZPtr contents;
+   /**
+    * Whether this CResult_UpdateFulfillHTLCDecodeErrorZ represents a success state.
+    */
+   bool result_ok;
+} LDKCResult_UpdateFulfillHTLCDecodeErrorZ;
+
+/**
+ * The contents of CResult_UpdateAddHTLCDecodeErrorZ
+ */
+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 LDKTransaction *result;
+   struct LDKUpdateAddHTLC *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_UpdateAddHTLCDecodeErrorZPtr;
 
 /**
- * A CResult_TransactionNoneZ represents the result of a fallible operation,
- * containing a crate::c_types::Transaction on success and a () 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_TransactionNoneZ {
+typedef struct LDKCResult_UpdateAddHTLCDecodeErrorZ {
    /**
-    * The contents of this CResult_TransactionNoneZ, accessible via either
+    * The contents of this CResult_UpdateAddHTLCDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_TransactionNoneZPtr contents;
+   union LDKCResult_UpdateAddHTLCDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_TransactionNoneZ represents a success state.
+    * Whether this CResult_UpdateAddHTLCDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_TransactionNoneZ;
+} LDKCResult_UpdateAddHTLCDecodeErrorZ;
+
+
 
 /**
- * The contents of CResult_NoneErrorZ
+ * A ping message to be sent or received from a peer
  */
-typedef union LDKCResult_NoneErrorZPtr {
+typedef struct MUST_USE_STRUCT LDKPing {
    /**
-    * 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;
+   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;
+} LDKPing;
+
+/**
+ * The contents of CResult_PingDecodeErrorZ
+ */
+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 LDKPing *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_PingDecodeErrorZPtr;
 
 /**
- * A CResult_NoneErrorZ represents the result of a fallible operation,
- * containing a () on success and a crate::c_types::IOError 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_NoneErrorZ {
+typedef struct LDKCResult_PingDecodeErrorZ {
    /**
-    * The contents of this CResult_NoneErrorZ, accessible via either
+    * The contents of this CResult_PingDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_NoneErrorZPtr contents;
+   union LDKCResult_PingDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_NoneErrorZ represents a success state.
+    * Whether this CResult_PingDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_NoneErrorZ;
+} LDKCResult_PingDecodeErrorZ;
+
+
 
 /**
- * A dynamically-allocated array of crate::c_types::derived::C2Tuple_BlockHashChannelMonitorZs of arbitrary size.
- * This corresponds to std::vector in C++
+ * A pong message to be sent or received from a peer
  */
-typedef struct LDKCVec_C2Tuple_BlockHashChannelMonitorZZ {
+typedef struct MUST_USE_STRUCT LDKPong {
    /**
-    * 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;
+   LDKnativePong *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;
+} LDKPong;
 
 /**
- * The contents of CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ
+ * The contents of CResult_PongDecodeErrorZ
  */
-typedef union LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZPtr {
+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 LDKCVec_C2Tuple_BlockHashChannelMonitorZZ *result;
+   struct LDKPong *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_PongDecodeErrorZPtr;
 
 /**
- * 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_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_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ {
+typedef struct LDKCResult_PongDecodeErrorZ {
    /**
-    * The contents of this CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ, accessible via either
+    * The contents of this CResult_PongDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZPtr contents;
+   union LDKCResult_PongDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ represents a success state.
+    * Whether this CResult_PongDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ;
+} LDKCResult_PongDecodeErrorZ;
 
 /**
- * Indicates an error on the client's part (usually some variant of attempting to use too-low or
- * too-high values)
+ * The contents of CResult_UnsignedChannelAnnouncementDecodeErrorZ
  */
-typedef enum LDKAPIError_Tag {
-   /**
-    * Indicates the API was wholly misused (see err for more). Cases where these can be returned
-    * are documented, but generally indicates some precondition of a function was violated.
-    */
-   LDKAPIError_APIMisuseError,
+typedef union LDKCResult_UnsignedChannelAnnouncementDecodeErrorZPtr {
    /**
-    * 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.
+    * A pointer to the contents in the success state.
+    * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   LDKAPIError_FeeRateTooHigh,
+   struct LDKUnsignedChannelAnnouncement *result;
    /**
-    * 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 error state.
+    * Reading from this pointer when `result_ok` is set is undefined.
     */
-   LDKAPIError_RouteError,
+   struct LDKDecodeError *err;
+} LDKCResult_UnsignedChannelAnnouncementDecodeErrorZPtr;
+
+/**
+ * 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_UnsignedChannelAnnouncementDecodeErrorZ {
    /**
-    * 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.
+    * The contents of this CResult_UnsignedChannelAnnouncementDecodeErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   LDKAPIError_ChannelUnavailable,
+   union LDKCResult_UnsignedChannelAnnouncementDecodeErrorZPtr contents;
    /**
-    * An attempt to call watch/update_channel returned an Err (ie you did this!), causing the
-    * attempted action to fail.
+    * Whether this CResult_UnsignedChannelAnnouncementDecodeErrorZ represents a success state.
     */
-   LDKAPIError_MonitorUpdateFailed,
+   bool result_ok;
+} LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ;
+
+/**
+ * The contents of CResult_ChannelAnnouncementDecodeErrorZ
+ */
+typedef union LDKCResult_ChannelAnnouncementDecodeErrorZPtr {
    /**
-    * 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.
     */
-   LDKAPIError_Sentinel,
-} LDKAPIError_Tag;
-
-typedef struct LDKAPIError_LDKAPIMisuseError_Body {
+   struct LDKChannelAnnouncement *result;
    /**
-    * A human-readable error message
+    * A pointer to the contents in the error state.
+    * Reading from this pointer when `result_ok` is set is undefined.
     */
-   struct LDKStr err;
-} LDKAPIError_LDKAPIMisuseError_Body;
+   struct LDKDecodeError *err;
+} LDKCResult_ChannelAnnouncementDecodeErrorZPtr;
 
-typedef struct LDKAPIError_LDKFeeRateTooHigh_Body {
+/**
+ * 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_ChannelAnnouncementDecodeErrorZ {
    /**
-    * A human-readable error message
+    * The contents of this CResult_ChannelAnnouncementDecodeErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   struct LDKStr err;
+   union LDKCResult_ChannelAnnouncementDecodeErrorZPtr contents;
    /**
-    * The feerate which was too high.
+    * Whether this CResult_ChannelAnnouncementDecodeErrorZ represents a success state.
     */
-   uint32_t feerate;
-} LDKAPIError_LDKFeeRateTooHigh_Body;
+   bool result_ok;
+} LDKCResult_ChannelAnnouncementDecodeErrorZ;
 
-typedef struct LDKAPIError_LDKRouteError_Body {
+
+
+/**
+ * The unsigned part of a channel_update
+ */
+typedef struct MUST_USE_STRUCT LDKUnsignedChannelUpdate {
    /**
-    * 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 {
+   LDKnativeUnsignedChannelUpdate *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 LDKStr 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;
+} LDKUnsignedChannelUpdate;
 
 /**
- * The contents of CResult_NoneAPIErrorZ
+ * The contents of CResult_UnsignedChannelUpdateDecodeErrorZ
  */
-typedef union LDKCResult_NoneAPIErrorZPtr {
+typedef union LDKCResult_UnsignedChannelUpdateDecodeErrorZPtr {
    /**
-    * 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 LDKUnsignedChannelUpdate *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_UnsignedChannelUpdateDecodeErrorZPtr;
 
 /**
- * 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_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_NoneAPIErrorZ {
+typedef struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ {
    /**
-    * The contents of this CResult_NoneAPIErrorZ, accessible via either
+    * The contents of this CResult_UnsignedChannelUpdateDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_NoneAPIErrorZPtr contents;
+   union LDKCResult_UnsignedChannelUpdateDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_NoneAPIErrorZ represents a success state.
+    * Whether this CResult_UnsignedChannelUpdateDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_NoneAPIErrorZ;
+} LDKCResult_UnsignedChannelUpdateDecodeErrorZ;
 
 /**
- * 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_ChannelUpdateDecodeErrorZ
  */
-typedef struct LDKCVec_CResult_NoneAPIErrorZZ {
+typedef union LDKCResult_ChannelUpdateDecodeErrorZPtr {
    /**
-    * 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 LDKChannelUpdate *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_ChannelUpdateDecodeErrorZPtr;
 
 /**
- * A dynamically-allocated array of crate::lightning::util::errors::APIErrors of arbitrary size.
- * This corresponds to std::vector in C++
+ * 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 LDKCVec_APIErrorZ {
+typedef struct LDKCResult_ChannelUpdateDecodeErrorZ {
    /**
-    * 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_ChannelUpdateDecodeErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   struct LDKAPIError *data;
+   union LDKCResult_ChannelUpdateDecodeErrorZPtr contents;
    /**
-    * The number of elements pointed to by `data`.
+    * Whether this CResult_ChannelUpdateDecodeErrorZ represents a success state.
     */
-   uintptr_t datalen;
-} LDKCVec_APIErrorZ;
+   bool result_ok;
+} LDKCResult_ChannelUpdateDecodeErrorZ;
 
 /**
- * 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_ErrorMessageDecodeErrorZ
  */
-typedef enum LDKPaymentSendFailure_Tag {
-   /**
-    * 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.
-    */
-   LDKPaymentSendFailure_ParameterError,
+typedef union LDKCResult_ErrorMessageDecodeErrorZPtr {
    /**
-    * 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 success state.
+    * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   LDKPaymentSendFailure_PathParameterError,
+   struct LDKErrorMessage *result;
    /**
-    * 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).
+    * A pointer to the contents in the error state.
+    * Reading from this pointer when `result_ok` is set is undefined.
     */
-   LDKPaymentSendFailure_AllFailedRetrySafe,
+   struct LDKDecodeError *err;
+} LDKCResult_ErrorMessageDecodeErrorZPtr;
+
+/**
+ * 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_ErrorMessageDecodeErrorZ {
    /**
-    * 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.
+    * The contents of this CResult_ErrorMessageDecodeErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   LDKPaymentSendFailure_PartialFailure,
+   union LDKCResult_ErrorMessageDecodeErrorZPtr contents;
    /**
-    * Must be last for serialization purposes
+    * Whether this CResult_ErrorMessageDecodeErrorZ represents a success state.
     */
-   LDKPaymentSendFailure_Sentinel,
-} LDKPaymentSendFailure_Tag;
+   bool result_ok;
+} LDKCResult_ErrorMessageDecodeErrorZ;
+
 
-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;
 
 /**
- * The contents of CResult_NonePaymentSendFailureZ
+ * The unsigned part of a node_announcement
  */
-typedef union LDKCResult_NonePaymentSendFailureZPtr {
+typedef struct MUST_USE_STRUCT LDKUnsignedNodeAnnouncement {
    /**
-    * 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;
+   LDKnativeUnsignedNodeAnnouncement *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 LDKPaymentSendFailure *err;
-} LDKCResult_NonePaymentSendFailureZPtr;
+   bool is_owned;
+} LDKUnsignedNodeAnnouncement;
 
 /**
- * A CResult_NonePaymentSendFailureZ represents the result of a fallible operation,
- * containing a () on success and a crate::lightning::ln::channelmanager::PaymentSendFailure on failure.
- * `result_ok` indicates the overall state, and the contents are provided via `contents`.
+ * The contents of CResult_UnsignedNodeAnnouncementDecodeErrorZ
  */
-typedef struct LDKCResult_NonePaymentSendFailureZ {
+typedef union LDKCResult_UnsignedNodeAnnouncementDecodeErrorZPtr {
    /**
-    * The contents of this CResult_NonePaymentSendFailureZ, accessible via either
-    * `err` or `result` depending on the state of `result_ok`.
+    * A pointer to the contents in the success state.
+    * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   union LDKCResult_NonePaymentSendFailureZPtr contents;
+   struct LDKUnsignedNodeAnnouncement *result;
    /**
-    * Whether this CResult_NonePaymentSendFailureZ represents a success state.
+    * A pointer to the contents in the error state.
+    * Reading from this pointer when `result_ok` is set is undefined.
     */
-   bool result_ok;
-} LDKCResult_NonePaymentSendFailureZ;
+   struct LDKDecodeError *err;
+} LDKCResult_UnsignedNodeAnnouncementDecodeErrorZPtr;
 
 /**
- * A tuple of 2 elements. See the individual fields for the types contained.
+ * 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 LDKC2Tuple_PaymentHashPaymentSecretZ {
+typedef struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ {
    /**
-    * The element at position 0
+    * The contents of this CResult_UnsignedNodeAnnouncementDecodeErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   struct LDKThirtyTwoBytes a;
+   union LDKCResult_UnsignedNodeAnnouncementDecodeErrorZPtr contents;
    /**
-    * The element at position 1
+    * Whether this CResult_UnsignedNodeAnnouncementDecodeErrorZ represents a success state.
     */
-   struct LDKThirtyTwoBytes b;
-} LDKC2Tuple_PaymentHashPaymentSecretZ;
+   bool result_ok;
+} LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ;
 
 /**
- * The contents of CResult_PaymentSecretAPIErrorZ
+ * The contents of CResult_NodeAnnouncementDecodeErrorZ
  */
-typedef union LDKCResult_PaymentSecretAPIErrorZPtr {
+typedef union LDKCResult_NodeAnnouncementDecodeErrorZPtr {
    /**
     * A pointer to the contents in the success state.
     * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   struct LDKThirtyTwoBytes *result;
+   struct LDKNodeAnnouncement *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_PaymentSecretAPIErrorZPtr;
+   struct LDKDecodeError *err;
+} LDKCResult_NodeAnnouncementDecodeErrorZPtr;
 
 /**
- * A CResult_PaymentSecretAPIErrorZ represents the result of a fallible operation,
- * containing a crate::c_types::ThirtyTwoBytes on success and a crate::lightning::util::errors::APIError on failure.
+ * 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 struct LDKCResult_PaymentSecretAPIErrorZ {
+typedef struct LDKCResult_NodeAnnouncementDecodeErrorZ {
    /**
-    * The contents of this CResult_PaymentSecretAPIErrorZ, accessible via either
+    * The contents of this CResult_NodeAnnouncementDecodeErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_PaymentSecretAPIErrorZPtr contents;
+   union LDKCResult_NodeAnnouncementDecodeErrorZPtr contents;
    /**
-    * Whether this CResult_PaymentSecretAPIErrorZ represents a success state.
+    * Whether this CResult_NodeAnnouncementDecodeErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_PaymentSecretAPIErrorZ;
+} LDKCResult_NodeAnnouncementDecodeErrorZ;
 
 /**
- * A dynamically-allocated array of crate::lightning::chain::channelmonitor::ChannelMonitors of arbitrary size.
- * This corresponds to std::vector in C++
+ * The contents of CResult_QueryShortChannelIdsDecodeErrorZ
  */
-typedef struct LDKCVec_ChannelMonitorZ {
+typedef union LDKCResult_QueryShortChannelIdsDecodeErrorZPtr {
    /**
-    * 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 LDKQueryShortChannelIds *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_QueryShortChannelIdsDecodeErrorZPtr;
 
 /**
- * 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_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 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;
-   /**
-    * 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
-    */
-   struct LDKCResult_NoneChannelMonitorUpdateErrZ (*watch_channel)(const void *this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor);
-   /**
-    * 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
-    */
-   struct LDKCResult_NoneChannelMonitorUpdateErrZ (*update_channel)(const void *this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitorUpdate update);
+typedef struct LDKCResult_QueryShortChannelIdsDecodeErrorZ {
    /**
-    * Returns any monitor events since the last call. Subsequent calls must only return new
-    * events.
+    * The contents of this CResult_QueryShortChannelIdsDecodeErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   struct LDKCVec_MonitorEventZ (*release_pending_monitor_events)(const void *this_arg);
+   union LDKCResult_QueryShortChannelIdsDecodeErrorZPtr 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_QueryShortChannelIdsDecodeErrorZ represents a success state.
     */
-   void (*free)(void *this_arg);
-} LDKWatch;
+   bool result_ok;
+} LDKCResult_QueryShortChannelIdsDecodeErrorZ;
+
+
 
 /**
- * An interface to send a transaction to the Bitcoin network.
+ * 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 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 MUST_USE_STRUCT LDKReplyShortChannelIdsEnd {
    /**
-    * Sends a transaction out to (hopefully) be mined.
+    * 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 (*broadcast_transaction)(const void *this_arg, struct LDKTransaction tx);
+   LDKnativeReplyShortChannelIdsEnd *inner;
    /**
-    * 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.
+    * 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.
     */
-   void (*free)(void *this_arg);
-} LDKBroadcasterInterface;
+   bool is_owned;
+} LDKReplyShortChannelIdsEnd;
 
 /**
- * A "slice" referencing some byte array. This is simply a length-tagged pointer which does not
- * own the memory pointed to by data.
+ * The contents of CResult_ReplyShortChannelIdsEndDecodeErrorZ
  */
-typedef struct LDKu8slice {
+typedef union LDKCResult_ReplyShortChannelIdsEndDecodeErrorZPtr {
    /**
-    * A pointer to the byte buffer
+    * A pointer to the contents in the success state.
+    * Reading from this pointer when `result_ok` is not set is undefined.
     */
-   const uint8_t *data;
+   struct LDKReplyShortChannelIdsEnd *result;
    /**
-    * The number of bytes 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;
-} LDKu8slice;
+   struct LDKDecodeError *err;
+} LDKCResult_ReplyShortChannelIdsEndDecodeErrorZPtr;
 
 /**
- * A trait to describe an object which can get user secrets and key material.
+ * 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 LDKKeysInterface {
-   /**
-    * 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;
-   /**
-    * 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);
+typedef struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ {
    /**
-    * Sign an invoice's preimage (note that this is the preimage of the invoice, not the HTLC's
-    * preimage). By parameterizing by the preimage instead of the hash, we allow implementors of
-    * this trait to parse the invoice and make sure they're signing what they expect, rather than
-    * blindly signing the hash.
+    * The contents of this CResult_ReplyShortChannelIdsEndDecodeErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   struct LDKCResult_RecoverableSignatureNoneZ (*sign_invoice)(const void *this_arg, struct LDKCVec_u8Z invoice_preimage);
+   union LDKCResult_ReplyShortChannelIdsEndDecodeErrorZPtr 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_ReplyShortChannelIdsEndDecodeErrorZ represents a success state.
     */
-   void (*free)(void *this_arg);
-} LDKKeysInterface;
+   bool result_ok;
+} LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ;
 
 /**
- * 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).
+ * The contents of CResult_QueryChannelRangeDecodeErrorZ
  */
-typedef struct LDKFeeEstimator {
+typedef union LDKCResult_QueryChannelRangeDecodeErrorZPtr {
    /**
-    * 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 LDKQueryChannelRange *result;
    /**
-    * 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)
+    * 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;
+
+/**
+ * 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 LDKCResult_QueryChannelRangeDecodeErrorZ {
+   /**
+    * The contents of this CResult_QueryChannelRangeDecodeErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   uint32_t (*get_est_sat_per_1000_weight)(const void *this_arg, enum LDKConfirmationTarget confirmation_target);
+   union LDKCResult_QueryChannelRangeDecodeErrorZPtr 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_QueryChannelRangeDecodeErrorZ represents a success state.
     */
-   void (*free)(void *this_arg);
-} LDKFeeEstimator;
+   bool result_ok;
+} LDKCResult_QueryChannelRangeDecodeErrorZ;
 
 /**
- * A trait encapsulating the operations required of a logger
+ * The contents of CResult_ReplyChannelRangeDecodeErrorZ
  */
-typedef struct LDKLogger {
+typedef union LDKCResult_ReplyChannelRangeDecodeErrorZPtr {
    /**
-    * 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 LDKReplyChannelRange *result;
    /**
-    * Logs the `Record`
+    * A pointer to the contents in the error state.
+    * Reading from this pointer when `result_ok` is set is undefined.
     */
-   void (*log)(const void *this_arg, const char *record);
+   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 {
    /**
-    * 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 contents of this CResult_ReplyChannelRangeDecodeErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
     */
-   void (*free)(void *this_arg);
-} LDKLogger;
+   union LDKCResult_ReplyChannelRangeDecodeErrorZPtr contents;
+   /**
+    * Whether this CResult_ReplyChannelRangeDecodeErrorZ represents a success state.
+    */
+   bool result_ok;
+} LDKCResult_ReplyChannelRangeDecodeErrorZ;
 
 
 
 /**
- * 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.
- *
- * 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.
+ * 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 LDKChannelManager {
+typedef struct MUST_USE_STRUCT LDKGossipTimestampFilter {
    /**
     * 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;
+   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;
-} LDKChannelManager;
+} LDKGossipTimestampFilter;
 
 /**
- * A tuple of 2 elements. See the individual fields for the types contained.
+ * The contents of CResult_GossipTimestampFilterDecodeErrorZ
  */
-typedef struct LDKC2Tuple_BlockHashChannelManagerZ {
+typedef union LDKCResult_GossipTimestampFilterDecodeErrorZPtr {
    /**
-    * 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 LDKThirtyTwoBytes a;
+   struct LDKGossipTimestampFilter *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 LDKChannelManager b;
-} LDKC2Tuple_BlockHashChannelManagerZ;
+   struct LDKDecodeError *err;
+} LDKCResult_GossipTimestampFilterDecodeErrorZPtr;
 
 /**
- * The contents of CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ
+ * 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 union LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZPtr {
+typedef struct LDKCResult_GossipTimestampFilterDecodeErrorZ {
+   /**
+    * The contents of this CResult_GossipTimestampFilterDecodeErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
+    */
+   union LDKCResult_GossipTimestampFilterDecodeErrorZPtr contents;
+   /**
+    * Whether this CResult_GossipTimestampFilterDecodeErrorZ represents a success state.
+    */
+   bool result_ok;
+} LDKCResult_GossipTimestampFilterDecodeErrorZ;
+
+/**
+ * When signing using a fallible method either an user-supplied `SignError` or a `CreationError`
+ * may occur.
+ */
+typedef enum LDKSignOrCreationError_Tag {
+   /**
+    * An error occurred during signing
+    */
+   LDKSignOrCreationError_SignError,
+   /**
+    * An error occurred while building the transaction
+    */
+   LDKSignOrCreationError_CreationError,
+   /**
+    * Must be last for serialization purposes
+    */
+   LDKSignOrCreationError_Sentinel,
+} LDKSignOrCreationError_Tag;
+
+typedef struct MUST_USE_STRUCT LDKSignOrCreationError {
+   LDKSignOrCreationError_Tag tag;
+   union {
+      struct {
+         enum LDKCreationError creation_error;
+      };
+   };
+} LDKSignOrCreationError;
+
+/**
+ * The contents of CResult_InvoiceSignOrCreationErrorZ
+ */
+typedef union LDKCResult_InvoiceSignOrCreationErrorZPtr {
    /**
     * 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 LDKInvoice *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;
+   struct LDKSignOrCreationError *err;
+} LDKCResult_InvoiceSignOrCreationErrorZPtr;
 
 /**
- * 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_InvoiceSignOrCreationErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning_invoice::Invoice on success and a crate::lightning_invoice::SignOrCreationError on failure.
  * `result_ok` indicates the overall state, and the contents are provided via `contents`.
  */
-typedef struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ {
+typedef struct LDKCResult_InvoiceSignOrCreationErrorZ {
    /**
-    * The contents of this CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ, accessible via either
+    * The contents of this CResult_InvoiceSignOrCreationErrorZ, accessible via either
     * `err` or `result` depending on the state of `result_ok`.
     */
-   union LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZPtr contents;
+   union LDKCResult_InvoiceSignOrCreationErrorZPtr contents;
    /**
-    * Whether this CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ represents a success state.
+    * Whether this CResult_InvoiceSignOrCreationErrorZ represents a success state.
     */
    bool result_ok;
-} LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ;
+} LDKCResult_InvoiceSignOrCreationErrorZ;
 
 /**
  * A trait indicating an object may generate message send events
@@ -8817,6 +8817,64 @@ typedef struct MUST_USE_STRUCT LDKFilesystemPersister {
 
 
 
+/**
+ * BackgroundProcessor takes care of tasks that (1) need to happen periodically to keep
+ * Rust-Lightning running properly, and (2) either can or should be run in the background. Its
+ * responsibilities are:
+ * * Monitoring whether the ChannelManager needs to be re-persisted to disk, and if so,
+ *   writing it to disk/backups by invoking the callback given to it at startup.
+ *   ChannelManager persistence should be done in the background.
+ * * Calling `ChannelManager::timer_tick_occurred()` and
+ *   `PeerManager::timer_tick_occurred()` every minute (can be done in the
+ *   background).
+ *
+ * Note that if ChannelManager persistence fails and the persisted manager becomes out-of-date,
+ * then there is a risk of channels force-closing on startup when the manager realizes it's
+ * outdated. However, as long as `ChannelMonitor` backups are sound, no funds besides those used
+ * for unilateral chain closure fees are at risk.
+ */
+typedef struct MUST_USE_STRUCT LDKBackgroundProcessor {
+   /**
+    * 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.
+    */
+   LDKnativeBackgroundProcessor *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;
+} LDKBackgroundProcessor;
+
+/**
+ * Trait which handles persisting a [`ChannelManager`] to disk.
+ *
+ * [`ChannelManager`]: lightning::ln::channelmanager::ChannelManager
+ */
+typedef struct LDKChannelManagerPersister {
+   /**
+    * 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;
+   /**
+    * Persist the given [`ChannelManager`] to disk, returning an error if persistence failed
+    * (which will cause the [`BackgroundProcessor`] which called this method to exit.
+    *
+    * [`ChannelManager`]: lightning::ln::channelmanager::ChannelManager
+    */
+   struct LDKCResult_NoneErrorZ (*persist_manager)(const void *this_arg, const struct LDKChannelManager *NONNULL_PTR channel_manager);
+   /**
+    * 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);
+} LDKChannelManagerPersister;
+
+
+
 /**
  * Data of the `RawInvoice` that is encoded in the data part
  */
@@ -8971,59 +9029,17 @@ void Transaction_free(struct LDKTransaction _res);
 /**
  * Frees the data pointed to by script_pubkey.
  */
-void TxOut_free(struct LDKTxOut _res);
-
-/**
- * Creates a new TxOut which has the same data as `orig` but with a new script buffer.
- */
-struct LDKTxOut TxOut_clone(const struct LDKTxOut *NONNULL_PTR orig);
-
-/**
- * Frees the data buffer, if chars_is_owned is set and len > 0.
- */
-void Str_free(struct LDKStr _res);
-
-/**
- * Creates a new CResult_ChannelConfigDecodeErrorZ in the success state.
- */
-struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_ok(struct LDKChannelConfig o);
-
-/**
- * Creates a new CResult_ChannelConfigDecodeErrorZ in the error state.
- */
-struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_err(struct LDKDecodeError e);
-
-/**
- * Frees any resources used by the CResult_ChannelConfigDecodeErrorZ.
- */
-void CResult_ChannelConfigDecodeErrorZ_free(struct LDKCResult_ChannelConfigDecodeErrorZ _res);
-
-/**
- * Creates a new CResult_ChannelConfigDecodeErrorZ which has the same data as `orig`
- * but with all dynamically-allocated buffers duplicated in new buffers.
- */
-struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_clone(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR orig);
-
-/**
- * Creates a new CResult_OutPointDecodeErrorZ in the success state.
- */
-struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_ok(struct LDKOutPoint o);
-
-/**
- * Creates a new CResult_OutPointDecodeErrorZ in the error state.
- */
-struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_err(struct LDKDecodeError e);
+void TxOut_free(struct LDKTxOut _res);
 
 /**
- * Frees any resources used by the CResult_OutPointDecodeErrorZ.
+ * Creates a new TxOut which has the same data as `orig` but with a new script buffer.
  */
-void CResult_OutPointDecodeErrorZ_free(struct LDKCResult_OutPointDecodeErrorZ _res);
+struct LDKTxOut TxOut_clone(const struct LDKTxOut *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_OutPointDecodeErrorZ which has the same data as `orig`
- * but with all dynamically-allocated buffers duplicated in new buffers.
+ * Frees the data buffer, if chars_is_owned is set and len > 0.
  */
-struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_clone(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR orig);
+void Str_free(struct LDKStr _res);
 
 /**
  * Creates a new CResult_SecretKeyErrorZ in the success state.
@@ -9055,6 +9071,12 @@ struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_err(enum LDKSecp256k1E
  */
 void CResult_PublicKeyErrorZ_free(struct LDKCResult_PublicKeyErrorZ _res);
 
+/**
+ * Creates a new CResult_PublicKeyErrorZ which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
+ */
+struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_clone(const struct LDKCResult_PublicKeyErrorZ *NONNULL_PTR orig);
+
 /**
  * Creates a new CResult_TxCreationKeysDecodeErrorZ in the success state.
  */
@@ -9112,6 +9134,12 @@ struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_err(enum LDK
  */
 void CResult_TxCreationKeysErrorZ_free(struct LDKCResult_TxCreationKeysErrorZ _res);
 
+/**
+ * Creates a new CResult_TxCreationKeysErrorZ which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
+ */
+struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_clone(const struct LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR orig);
+
 /**
  * Constructs a new COption_u32Z containing a u32
  */
@@ -9301,2084 +9329,2186 @@ void CResult_CVec_SignatureZNoneZ_free(struct LDKCResult_CVec_SignatureZNoneZ _r
 struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_clone(const struct LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_SiPrefixNoneZ in the success state.
+ * Creates a new CResult_NoneErrorZ in the success state.
  */
-struct LDKCResult_SiPrefixNoneZ CResult_SiPrefixNoneZ_ok(enum LDKSiPrefix o);
+struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_ok(void);
 
 /**
- * Creates a new CResult_SiPrefixNoneZ in the error state.
+ * Creates a new CResult_NoneErrorZ in the error state.
  */
-struct LDKCResult_SiPrefixNoneZ CResult_SiPrefixNoneZ_err(void);
+struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_err(enum LDKIOError e);
 
 /**
- * Frees any resources used by the CResult_SiPrefixNoneZ.
+ * Frees any resources used by the CResult_NoneErrorZ.
  */
-void CResult_SiPrefixNoneZ_free(struct LDKCResult_SiPrefixNoneZ _res);
+void CResult_NoneErrorZ_free(struct LDKCResult_NoneErrorZ _res);
 
 /**
- * Creates a new CResult_SiPrefixNoneZ which has the same data as `orig`
+ * Creates a new CResult_NoneErrorZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_SiPrefixNoneZ CResult_SiPrefixNoneZ_clone(const struct LDKCResult_SiPrefixNoneZ *NONNULL_PTR orig);
+struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_clone(const struct LDKCResult_NoneErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_InvoiceNoneZ in the success state.
+ * Creates a new CResult_RouteHopDecodeErrorZ in the success state.
  */
-struct LDKCResult_InvoiceNoneZ CResult_InvoiceNoneZ_ok(struct LDKInvoice o);
+struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_ok(struct LDKRouteHop o);
 
 /**
- * Creates a new CResult_InvoiceNoneZ in the error state.
+ * Creates a new CResult_RouteHopDecodeErrorZ in the error state.
  */
-struct LDKCResult_InvoiceNoneZ CResult_InvoiceNoneZ_err(void);
+struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Frees any resources used by the CResult_InvoiceNoneZ.
+ * Frees any resources used by the CResult_RouteHopDecodeErrorZ.
  */
-void CResult_InvoiceNoneZ_free(struct LDKCResult_InvoiceNoneZ _res);
+void CResult_RouteHopDecodeErrorZ_free(struct LDKCResult_RouteHopDecodeErrorZ _res);
 
 /**
- * Creates a new CResult_InvoiceNoneZ which has the same data as `orig`
+ * Creates a new CResult_RouteHopDecodeErrorZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_InvoiceNoneZ CResult_InvoiceNoneZ_clone(const struct LDKCResult_InvoiceNoneZ *NONNULL_PTR orig);
+struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_clone(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_SignedRawInvoiceNoneZ in the success state.
+ * Frees the buffer pointed to by `data` if `datalen` is non-0.
  */
-struct LDKCResult_SignedRawInvoiceNoneZ CResult_SignedRawInvoiceNoneZ_ok(struct LDKSignedRawInvoice o);
+void CVec_RouteHopZ_free(struct LDKCVec_RouteHopZ _res);
 
 /**
- * Creates a new CResult_SignedRawInvoiceNoneZ in the error state.
+ * Frees the buffer pointed to by `data` if `datalen` is non-0.
  */
-struct LDKCResult_SignedRawInvoiceNoneZ CResult_SignedRawInvoiceNoneZ_err(void);
+void CVec_CVec_RouteHopZZ_free(struct LDKCVec_CVec_RouteHopZZ _res);
 
 /**
- * Frees any resources used by the CResult_SignedRawInvoiceNoneZ.
+ * Creates a new CResult_RouteDecodeErrorZ in the success state.
  */
-void CResult_SignedRawInvoiceNoneZ_free(struct LDKCResult_SignedRawInvoiceNoneZ _res);
+struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_ok(struct LDKRoute o);
 
 /**
- * Creates a new CResult_SignedRawInvoiceNoneZ which has the same data as `orig`
+ * Creates a new CResult_RouteDecodeErrorZ in the error state.
+ */
+struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_err(struct LDKDecodeError e);
+
+/**
+ * Frees any resources used by the CResult_RouteDecodeErrorZ.
+ */
+void CResult_RouteDecodeErrorZ_free(struct LDKCResult_RouteDecodeErrorZ _res);
+
+/**
+ * Creates a new CResult_RouteDecodeErrorZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_SignedRawInvoiceNoneZ CResult_SignedRawInvoiceNoneZ_clone(const struct LDKCResult_SignedRawInvoiceNoneZ *NONNULL_PTR orig);
+struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_clone(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR orig);
+
+/**
+ * Constructs a new COption_u64Z containing a u64
+ */
+struct LDKCOption_u64Z COption_u64Z_some(uint64_t o);
+
+/**
+ * Constructs a new COption_u64Z containing nothing
+ */
+struct LDKCOption_u64Z COption_u64Z_none(void);
+
+/**
+ * Frees any resources associated with the u64, if we are in the Some state
+ */
+void COption_u64Z_free(struct LDKCOption_u64Z _res);
+
+/**
+ * Creates a new COption_u64Z which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
+ */
+struct LDKCOption_u64Z COption_u64Z_clone(const struct LDKCOption_u64Z *NONNULL_PTR orig);
 
 /**
  * Frees the buffer pointed to by `data` if `datalen` is non-0.
  */
-void CVec_u8Z_free(struct LDKCVec_u8Z _res);
+void CVec_ChannelDetailsZ_free(struct LDKCVec_ChannelDetailsZ _res);
 
 /**
- * Creates a new C3Tuple_RawInvoice_u832InvoiceSignatureZ from the contained elements.
+ * Frees the buffer pointed to by `data` if `datalen` is non-0.
  */
-struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(struct LDKRawInvoice a, struct LDKThirtyTwoBytes b, struct LDKInvoiceSignature c);
+void CVec_RouteHintHopZ_free(struct LDKCVec_RouteHintHopZ _res);
 
 /**
- * Frees any resources used by the C3Tuple_RawInvoice_u832InvoiceSignatureZ.
+ * Creates a new CResult_RouteLightningErrorZ in the success state.
  */
-void C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ _res);
+struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_ok(struct LDKRoute o);
 
 /**
- * Creates a new CResult_PayeePubKeyErrorZ in the success state.
+ * Creates a new CResult_RouteLightningErrorZ in the error state.
  */
-struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_ok(struct LDKPayeePubKey o);
+struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_err(struct LDKLightningError e);
 
 /**
- * Creates a new CResult_PayeePubKeyErrorZ in the error state.
+ * Frees any resources used by the CResult_RouteLightningErrorZ.
  */
-struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_err(enum LDKSecp256k1Error e);
+void CResult_RouteLightningErrorZ_free(struct LDKCResult_RouteLightningErrorZ _res);
 
 /**
- * Frees any resources used by the CResult_PayeePubKeyErrorZ.
+ * Creates a new CResult_RouteLightningErrorZ which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-void CResult_PayeePubKeyErrorZ_free(struct LDKCResult_PayeePubKeyErrorZ _res);
+struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_clone(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR orig);
 
 /**
- * Frees the buffer pointed to by `data` if `datalen` is non-0.
+ * Creates a new CResult_TxOutAccessErrorZ in the success state.
  */
-void CVec_RouteHintZ_free(struct LDKCVec_RouteHintZ _res);
+struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_ok(struct LDKTxOut o);
 
 /**
- * Constructs a new COption_u64Z containing a u64
+ * Creates a new CResult_TxOutAccessErrorZ in the error state.
  */
-struct LDKCOption_u64Z COption_u64Z_some(uint64_t o);
+struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_err(enum LDKAccessError e);
 
 /**
- * Constructs a new COption_u64Z containing nothing
+ * Frees any resources used by the CResult_TxOutAccessErrorZ.
  */
-struct LDKCOption_u64Z COption_u64Z_none(void);
+void CResult_TxOutAccessErrorZ_free(struct LDKCResult_TxOutAccessErrorZ _res);
 
 /**
- * Frees any resources associated with the u64, if we are in the Some state
+ * Creates a new CResult_TxOutAccessErrorZ which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-void COption_u64Z_free(struct LDKCOption_u64Z _res);
+struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_clone(const struct LDKCResult_TxOutAccessErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new COption_u64Z which has the same data as `orig`
+ * Creates a new tuple which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCOption_u64Z COption_u64Z_clone(const struct LDKCOption_u64Z *NONNULL_PTR orig);
+struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_clone(const struct LDKC2Tuple_usizeTransactionZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_PositiveTimestampCreationErrorZ in the success state.
+ * Creates a new C2Tuple_usizeTransactionZ from the contained elements.
  */
-struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_ok(struct LDKPositiveTimestamp o);
+struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_new(uintptr_t a, struct LDKTransaction b);
 
 /**
- * Creates a new CResult_PositiveTimestampCreationErrorZ in the error state.
+ * Frees any resources used by the C2Tuple_usizeTransactionZ.
  */
-struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_err(enum LDKCreationError e);
+void C2Tuple_usizeTransactionZ_free(struct LDKC2Tuple_usizeTransactionZ _res);
 
 /**
- * Frees any resources used by the CResult_PositiveTimestampCreationErrorZ.
+ * Frees the buffer pointed to by `data` if `datalen` is non-0.
  */
-void CResult_PositiveTimestampCreationErrorZ_free(struct LDKCResult_PositiveTimestampCreationErrorZ _res);
+void CVec_C2Tuple_usizeTransactionZZ_free(struct LDKCVec_C2Tuple_usizeTransactionZZ _res);
 
 /**
- * Creates a new CResult_PositiveTimestampCreationErrorZ which has the same data as `orig`
+ * Frees the buffer pointed to by `data` if `datalen` is non-0.
+ */
+void CVec_TxidZ_free(struct LDKCVec_TxidZ _res);
+
+/**
+ * Creates a new CResult_NoneChannelMonitorUpdateErrZ in the success state.
+ */
+struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_ok(void);
+
+/**
+ * Creates a new CResult_NoneChannelMonitorUpdateErrZ in the error state.
+ */
+struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_err(enum LDKChannelMonitorUpdateErr e);
+
+/**
+ * Frees any resources used by the CResult_NoneChannelMonitorUpdateErrZ.
+ */
+void CResult_NoneChannelMonitorUpdateErrZ_free(struct LDKCResult_NoneChannelMonitorUpdateErrZ _res);
+
+/**
+ * Creates a new CResult_NoneChannelMonitorUpdateErrZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_clone(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR orig);
+struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_clone(const struct LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_NoneSemanticErrorZ in the success state.
+ * Frees the buffer pointed to by `data` if `datalen` is non-0.
  */
-struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_ok(void);
+void CVec_MonitorEventZ_free(struct LDKCVec_MonitorEventZ _res);
 
 /**
- * Creates a new CResult_NoneSemanticErrorZ in the error state.
+ * Constructs a new COption_C2Tuple_usizeTransactionZZ containing a crate::c_types::derived::C2Tuple_usizeTransactionZ
  */
-struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_err(enum LDKSemanticError e);
+struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_some(struct LDKC2Tuple_usizeTransactionZ o);
 
 /**
- * Frees any resources used by the CResult_NoneSemanticErrorZ.
+ * Constructs a new COption_C2Tuple_usizeTransactionZZ containing nothing
  */
-void CResult_NoneSemanticErrorZ_free(struct LDKCResult_NoneSemanticErrorZ _res);
+struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_none(void);
 
 /**
- * Creates a new CResult_NoneSemanticErrorZ which has the same data as `orig`
+ * Frees any resources associated with the crate::c_types::derived::C2Tuple_usizeTransactionZ, if we are in the Some state
+ */
+void COption_C2Tuple_usizeTransactionZZ_free(struct LDKCOption_C2Tuple_usizeTransactionZZ _res);
+
+/**
+ * Creates a new COption_C2Tuple_usizeTransactionZZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_clone(const struct LDKCResult_NoneSemanticErrorZ *NONNULL_PTR orig);
+struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_clone(const struct LDKCOption_C2Tuple_usizeTransactionZZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_InvoiceSemanticErrorZ in the success state.
+ * Frees the buffer pointed to by `data` if `datalen` is non-0.
  */
-struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_ok(struct LDKInvoice o);
+void CVec_SpendableOutputDescriptorZ_free(struct LDKCVec_SpendableOutputDescriptorZ _res);
 
 /**
- * Creates a new CResult_InvoiceSemanticErrorZ in the error state.
+ * Frees the buffer pointed to by `data` if `datalen` is non-0.
  */
-struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_err(enum LDKSemanticError e);
+void CVec_MessageSendEventZ_free(struct LDKCVec_MessageSendEventZ _res);
 
 /**
- * Frees any resources used by the CResult_InvoiceSemanticErrorZ.
+ * Creates a new CResult_InitFeaturesDecodeErrorZ in the success state.
  */
-void CResult_InvoiceSemanticErrorZ_free(struct LDKCResult_InvoiceSemanticErrorZ _res);
+struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_ok(struct LDKInitFeatures o);
+
+/**
+ * Creates a new CResult_InitFeaturesDecodeErrorZ in the error state.
+ */
+struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
+
+/**
+ * Frees any resources used by the CResult_InitFeaturesDecodeErrorZ.
+ */
+void CResult_InitFeaturesDecodeErrorZ_free(struct LDKCResult_InitFeaturesDecodeErrorZ _res);
+
+/**
+ * Creates a new CResult_NodeFeaturesDecodeErrorZ in the success state.
+ */
+struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_ok(struct LDKNodeFeatures o);
+
+/**
+ * Creates a new CResult_NodeFeaturesDecodeErrorZ in the error state.
+ */
+struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
+
+/**
+ * Frees any resources used by the CResult_NodeFeaturesDecodeErrorZ.
+ */
+void CResult_NodeFeaturesDecodeErrorZ_free(struct LDKCResult_NodeFeaturesDecodeErrorZ _res);
+
+/**
+ * Creates a new CResult_ChannelFeaturesDecodeErrorZ in the success state.
+ */
+struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_ok(struct LDKChannelFeatures o);
+
+/**
+ * Creates a new CResult_ChannelFeaturesDecodeErrorZ in the error state.
+ */
+struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
+
+/**
+ * Frees any resources used by the CResult_ChannelFeaturesDecodeErrorZ.
+ */
+void CResult_ChannelFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelFeaturesDecodeErrorZ _res);
+
+/**
+ * Creates a new CResult_InvoiceFeaturesDecodeErrorZ in the success state.
+ */
+struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_ok(struct LDKInvoiceFeatures o);
+
+/**
+ * Creates a new CResult_InvoiceFeaturesDecodeErrorZ in the error state.
+ */
+struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Creates a new CResult_InvoiceSemanticErrorZ which has the same data as `orig`
- * but with all dynamically-allocated buffers duplicated in new buffers.
+ * Frees any resources used by the CResult_InvoiceFeaturesDecodeErrorZ.
  */
-struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_clone(const struct LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR orig);
+void CResult_InvoiceFeaturesDecodeErrorZ_free(struct LDKCResult_InvoiceFeaturesDecodeErrorZ _res);
 
 /**
- * Creates a new CResult_DescriptionCreationErrorZ in the success state.
+ * Creates a new CResult_DelayedPaymentOutputDescriptorDecodeErrorZ in the success state.
  */
-struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_ok(struct LDKDescription o);
+struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKDelayedPaymentOutputDescriptor o);
 
 /**
- * Creates a new CResult_DescriptionCreationErrorZ in the error state.
+ * Creates a new CResult_DelayedPaymentOutputDescriptorDecodeErrorZ in the error state.
  */
-struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_err(enum LDKCreationError e);
+struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Frees any resources used by the CResult_DescriptionCreationErrorZ.
+ * Frees any resources used by the CResult_DelayedPaymentOutputDescriptorDecodeErrorZ.
  */
-void CResult_DescriptionCreationErrorZ_free(struct LDKCResult_DescriptionCreationErrorZ _res);
+void CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ _res);
 
 /**
- * Creates a new CResult_DescriptionCreationErrorZ which has the same data as `orig`
+ * Creates a new CResult_DelayedPaymentOutputDescriptorDecodeErrorZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_clone(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR orig);
+struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_ExpiryTimeCreationErrorZ in the success state.
+ * Creates a new CResult_StaticPaymentOutputDescriptorDecodeErrorZ in the success state.
  */
-struct LDKCResult_ExpiryTimeCreationErrorZ CResult_ExpiryTimeCreationErrorZ_ok(struct LDKExpiryTime o);
+struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKStaticPaymentOutputDescriptor o);
 
 /**
- * Creates a new CResult_ExpiryTimeCreationErrorZ in the error state.
+ * Creates a new CResult_StaticPaymentOutputDescriptorDecodeErrorZ in the error state.
  */
-struct LDKCResult_ExpiryTimeCreationErrorZ CResult_ExpiryTimeCreationErrorZ_err(enum LDKCreationError e);
+struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Frees any resources used by the CResult_ExpiryTimeCreationErrorZ.
+ * Frees any resources used by the CResult_StaticPaymentOutputDescriptorDecodeErrorZ.
  */
-void CResult_ExpiryTimeCreationErrorZ_free(struct LDKCResult_ExpiryTimeCreationErrorZ _res);
+void CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ _res);
 
 /**
- * Creates a new CResult_ExpiryTimeCreationErrorZ which has the same data as `orig`
+ * Creates a new CResult_StaticPaymentOutputDescriptorDecodeErrorZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_ExpiryTimeCreationErrorZ CResult_ExpiryTimeCreationErrorZ_clone(const struct LDKCResult_ExpiryTimeCreationErrorZ *NONNULL_PTR orig);
-
-/**
- * Frees the buffer pointed to by `data` if `datalen` is non-0.
- */
-void CVec_RouteHintHopZ_free(struct LDKCVec_RouteHintHopZ _res);
+struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_RouteHintCreationErrorZ in the success state.
+ * Creates a new CResult_SpendableOutputDescriptorDecodeErrorZ in the success state.
  */
-struct LDKCResult_RouteHintCreationErrorZ CResult_RouteHintCreationErrorZ_ok(struct LDKRouteHint o);
+struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_ok(struct LDKSpendableOutputDescriptor o);
 
 /**
- * Creates a new CResult_RouteHintCreationErrorZ in the error state.
+ * Creates a new CResult_SpendableOutputDescriptorDecodeErrorZ in the error state.
  */
-struct LDKCResult_RouteHintCreationErrorZ CResult_RouteHintCreationErrorZ_err(enum LDKCreationError e);
+struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Frees any resources used by the CResult_RouteHintCreationErrorZ.
+ * Frees any resources used by the CResult_SpendableOutputDescriptorDecodeErrorZ.
  */
-void CResult_RouteHintCreationErrorZ_free(struct LDKCResult_RouteHintCreationErrorZ _res);
+void CResult_SpendableOutputDescriptorDecodeErrorZ_free(struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ _res);
 
 /**
- * Creates a new CResult_RouteHintCreationErrorZ which has the same data as `orig`
+ * Creates a new CResult_SpendableOutputDescriptorDecodeErrorZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_RouteHintCreationErrorZ CResult_RouteHintCreationErrorZ_clone(const struct LDKCResult_RouteHintCreationErrorZ *NONNULL_PTR orig);
+struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_StringErrorZ in the success state.
+ * Creates a new tuple which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_StringErrorZ CResult_StringErrorZ_ok(struct LDKStr o);
+struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_clone(const struct LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_StringErrorZ in the error state.
+ * Creates a new C2Tuple_SignatureCVec_SignatureZZ from the contained elements.
  */
-struct LDKCResult_StringErrorZ CResult_StringErrorZ_err(enum LDKSecp256k1Error e);
+struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_new(struct LDKSignature a, struct LDKCVec_SignatureZ b);
 
 /**
- * Frees any resources used by the CResult_StringErrorZ.
+ * Frees any resources used by the C2Tuple_SignatureCVec_SignatureZZ.
  */
-void CResult_StringErrorZ_free(struct LDKCResult_StringErrorZ _res);
+void C2Tuple_SignatureCVec_SignatureZZ_free(struct LDKC2Tuple_SignatureCVec_SignatureZZ _res);
 
 /**
- * Creates a new CResult_ChannelMonitorUpdateDecodeErrorZ in the success state.
+ * Creates a new CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ in the success state.
  */
-struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_ok(struct LDKChannelMonitorUpdate o);
+struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(struct LDKC2Tuple_SignatureCVec_SignatureZZ o);
 
 /**
- * Creates a new CResult_ChannelMonitorUpdateDecodeErrorZ in the error state.
+ * Creates a new CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ in the error state.
  */
-struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_err(struct LDKDecodeError e);
+struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(void);
 
 /**
- * Frees any resources used by the CResult_ChannelMonitorUpdateDecodeErrorZ.
+ * Frees any resources used by the CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ.
  */
-void CResult_ChannelMonitorUpdateDecodeErrorZ_free(struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ _res);
+void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ _res);
 
 /**
- * Creates a new CResult_ChannelMonitorUpdateDecodeErrorZ which has the same data as `orig`
+ * Creates a new CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR orig);
+struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(const struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_HTLCUpdateDecodeErrorZ in the success state.
+ * Creates a new CResult_SignatureNoneZ in the success state.
  */
-struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_ok(struct LDKHTLCUpdate o);
+struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_ok(struct LDKSignature o);
 
 /**
- * Creates a new CResult_HTLCUpdateDecodeErrorZ in the error state.
+ * Creates a new CResult_SignatureNoneZ in the error state.
  */
-struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_err(struct LDKDecodeError e);
+struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_err(void);
 
 /**
- * Frees any resources used by the CResult_HTLCUpdateDecodeErrorZ.
+ * Frees any resources used by the CResult_SignatureNoneZ.
  */
-void CResult_HTLCUpdateDecodeErrorZ_free(struct LDKCResult_HTLCUpdateDecodeErrorZ _res);
+void CResult_SignatureNoneZ_free(struct LDKCResult_SignatureNoneZ _res);
 
 /**
- * Creates a new CResult_HTLCUpdateDecodeErrorZ which has the same data as `orig`
+ * Creates a new CResult_SignatureNoneZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_clone(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR orig);
-
-/**
- * Creates a new CResult_NoneMonitorUpdateErrorZ in the success state.
- */
-struct LDKCResult_NoneMonitorUpdateErrorZ CResult_NoneMonitorUpdateErrorZ_ok(void);
+struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_clone(const struct LDKCResult_SignatureNoneZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_NoneMonitorUpdateErrorZ in the error state.
+ * Creates a new CResult_SignDecodeErrorZ in the success state.
  */
-struct LDKCResult_NoneMonitorUpdateErrorZ CResult_NoneMonitorUpdateErrorZ_err(struct LDKMonitorUpdateError e);
+struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_ok(struct LDKSign o);
 
 /**
- * Frees any resources used by the CResult_NoneMonitorUpdateErrorZ.
+ * Creates a new CResult_SignDecodeErrorZ in the error state.
  */
-void CResult_NoneMonitorUpdateErrorZ_free(struct LDKCResult_NoneMonitorUpdateErrorZ _res);
+struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Creates a new CResult_NoneMonitorUpdateErrorZ which has the same data as `orig`
- * but with all dynamically-allocated buffers duplicated in new buffers.
+ * Frees any resources used by the CResult_SignDecodeErrorZ.
  */
-struct LDKCResult_NoneMonitorUpdateErrorZ CResult_NoneMonitorUpdateErrorZ_clone(const struct LDKCResult_NoneMonitorUpdateErrorZ *NONNULL_PTR orig);
+void CResult_SignDecodeErrorZ_free(struct LDKCResult_SignDecodeErrorZ _res);
 
 /**
- * Creates a new tuple which has the same data as `orig`
+ * Creates a new CResult_SignDecodeErrorZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_clone(const struct LDKC2Tuple_OutPointScriptZ *NONNULL_PTR orig);
+struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_clone(const struct LDKCResult_SignDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new C2Tuple_OutPointScriptZ from the contained elements.
+ * Frees the buffer pointed to by `data` if `datalen` is non-0.
  */
-struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_new(struct LDKOutPoint a, struct LDKCVec_u8Z b);
+void CVec_u8Z_free(struct LDKCVec_u8Z _res);
 
 /**
- * Frees any resources used by the C2Tuple_OutPointScriptZ.
+ * Creates a new CResult_RecoverableSignatureNoneZ in the success state.
  */
-void C2Tuple_OutPointScriptZ_free(struct LDKC2Tuple_OutPointScriptZ _res);
+struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_ok(struct LDKRecoverableSignature o);
 
 /**
- * Creates a new tuple which has the same data as `orig`
- * but with all dynamically-allocated buffers duplicated in new buffers.
+ * Creates a new CResult_RecoverableSignatureNoneZ in the error state.
  */
-struct LDKC2Tuple_u32ScriptZ C2Tuple_u32ScriptZ_clone(const struct LDKC2Tuple_u32ScriptZ *NONNULL_PTR orig);
+struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_err(void);
 
 /**
- * Creates a new C2Tuple_u32ScriptZ from the contained elements.
+ * Frees any resources used by the CResult_RecoverableSignatureNoneZ.
  */
-struct LDKC2Tuple_u32ScriptZ C2Tuple_u32ScriptZ_new(uint32_t a, struct LDKCVec_u8Z b);
+void CResult_RecoverableSignatureNoneZ_free(struct LDKCResult_RecoverableSignatureNoneZ _res);
 
 /**
- * Frees any resources used by the C2Tuple_u32ScriptZ.
+ * Creates a new CResult_RecoverableSignatureNoneZ which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-void C2Tuple_u32ScriptZ_free(struct LDKC2Tuple_u32ScriptZ _res);
+struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_clone(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR orig);
 
 /**
  * Frees the buffer pointed to by `data` if `datalen` is non-0.
  */
-void CVec_C2Tuple_u32ScriptZZ_free(struct LDKCVec_C2Tuple_u32ScriptZZ _res);
+void CVec_CVec_u8ZZ_free(struct LDKCVec_CVec_u8ZZ _res);
 
 /**
- * Creates a new C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ from the contained elements.
+ * Creates a new CResult_CVec_CVec_u8ZZNoneZ in the success state.
  */
-struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32ScriptZZ b);
+struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_ok(struct LDKCVec_CVec_u8ZZ o);
 
 /**
- * Frees any resources used by the C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ.
+ * Creates a new CResult_CVec_CVec_u8ZZNoneZ in the error state.
  */
-void C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ _res);
+struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_err(void);
 
 /**
- * Frees the buffer pointed to by `data` if `datalen` is non-0.
+ * Frees any resources used by the CResult_CVec_CVec_u8ZZNoneZ.
  */
-void CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ _res);
+void CResult_CVec_CVec_u8ZZNoneZ_free(struct LDKCResult_CVec_CVec_u8ZZNoneZ _res);
 
 /**
- * Frees the buffer pointed to by `data` if `datalen` is non-0.
+ * Creates a new CResult_CVec_CVec_u8ZZNoneZ which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-void CVec_MonitorEventZ_free(struct LDKCVec_MonitorEventZ _res);
+struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_clone(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR orig);
 
 /**
- * Frees the buffer pointed to by `data` if `datalen` is non-0.
+ * Creates a new CResult_InMemorySignerDecodeErrorZ in the success state.
  */
-void CVec_EventZ_free(struct LDKCVec_EventZ _res);
+struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_ok(struct LDKInMemorySigner o);
 
 /**
- * Frees the buffer pointed to by `data` if `datalen` is non-0.
+ * Creates a new CResult_InMemorySignerDecodeErrorZ in the error state.
  */
-void CVec_TransactionZ_free(struct LDKCVec_TransactionZ _res);
+struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Creates a new C2Tuple_usizeTransactionZ from the contained elements.
+ * Frees any resources used by the CResult_InMemorySignerDecodeErrorZ.
  */
-struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_new(uintptr_t a, struct LDKTransaction b);
+void CResult_InMemorySignerDecodeErrorZ_free(struct LDKCResult_InMemorySignerDecodeErrorZ _res);
 
 /**
- * Frees any resources used by the C2Tuple_usizeTransactionZ.
+ * Creates a new CResult_InMemorySignerDecodeErrorZ which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-void C2Tuple_usizeTransactionZ_free(struct LDKC2Tuple_usizeTransactionZ _res);
+struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_clone(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR orig);
 
 /**
  * Frees the buffer pointed to by `data` if `datalen` is non-0.
  */
-void CVec_C2Tuple_usizeTransactionZZ_free(struct LDKCVec_C2Tuple_usizeTransactionZZ _res);
-
-/**
- * Creates a new tuple which has the same data as `orig`
- * but with all dynamically-allocated buffers duplicated in new buffers.
- */
-struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_clone(const struct LDKC2Tuple_u32TxOutZ *NONNULL_PTR orig);
+void CVec_TxOutZ_free(struct LDKCVec_TxOutZ _res);
 
 /**
- * Creates a new C2Tuple_u32TxOutZ from the contained elements.
+ * Creates a new CResult_TransactionNoneZ in the success state.
  */
-struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_new(uint32_t a, struct LDKTxOut b);
+struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_ok(struct LDKTransaction o);
 
 /**
- * Frees any resources used by the C2Tuple_u32TxOutZ.
+ * Creates a new CResult_TransactionNoneZ in the error state.
  */
-void C2Tuple_u32TxOutZ_free(struct LDKC2Tuple_u32TxOutZ _res);
+struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_err(void);
 
 /**
- * Frees the buffer pointed to by `data` if `datalen` is non-0.
+ * Frees any resources used by the CResult_TransactionNoneZ.
  */
-void CVec_C2Tuple_u32TxOutZZ_free(struct LDKCVec_C2Tuple_u32TxOutZZ _res);
+void CResult_TransactionNoneZ_free(struct LDKCResult_TransactionNoneZ _res);
 
 /**
- * Creates a new C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ from the contained elements.
+ * Creates a new CResult_TransactionNoneZ which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32TxOutZZ b);
+struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_clone(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR orig);
 
 /**
- * Frees any resources used by the C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ.
+ * Creates a new C2Tuple_BlockHashChannelMonitorZ from the contained elements.
  */
-void C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ _res);
+struct LDKC2Tuple_BlockHashChannelMonitorZ C2Tuple_BlockHashChannelMonitorZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelMonitor b);
 
 /**
- * Frees the buffer pointed to by `data` if `datalen` is non-0.
+ * Frees any resources used by the C2Tuple_BlockHashChannelMonitorZ.
  */
-void CVec_TransactionOutputsZ_free(struct LDKCVec_TransactionOutputsZ _res);
+void C2Tuple_BlockHashChannelMonitorZ_free(struct LDKC2Tuple_BlockHashChannelMonitorZ _res);
 
 /**
  * Frees the buffer pointed to by `data` if `datalen` is non-0.
  */
-void CVec_TxidZ_free(struct LDKCVec_TxidZ _res);
+void CVec_C2Tuple_BlockHashChannelMonitorZZ_free(struct LDKCVec_C2Tuple_BlockHashChannelMonitorZZ _res);
 
 /**
- * Creates a new CResult_NoneChannelMonitorUpdateErrZ in the success state.
+ * Creates a new CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ in the success state.
  */
-struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_ok(void);
+struct LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_ok(struct LDKCVec_C2Tuple_BlockHashChannelMonitorZZ o);
 
 /**
- * Creates a new CResult_NoneChannelMonitorUpdateErrZ in the error state.
+ * Creates a new CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ in the error state.
  */
-struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_err(enum LDKChannelMonitorUpdateErr e);
+struct LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_err(enum LDKIOError e);
 
 /**
- * Frees any resources used by the CResult_NoneChannelMonitorUpdateErrZ.
+ * Frees any resources used by the CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ.
  */
-void CResult_NoneChannelMonitorUpdateErrZ_free(struct LDKCResult_NoneChannelMonitorUpdateErrZ _res);
+void CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_free(struct LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ _res);
 
 /**
- * Creates a new CResult_NoneChannelMonitorUpdateErrZ which has the same data as `orig`
- * but with all dynamically-allocated buffers duplicated in new buffers.
+ * Creates a new CResult_NoneAPIErrorZ in the success state.
  */
-struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_clone(const struct LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR orig);
+struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_ok(void);
 
 /**
- * Creates a new C2Tuple_BlockHashChannelMonitorZ from the contained elements.
+ * Creates a new CResult_NoneAPIErrorZ in the error state.
  */
-struct LDKC2Tuple_BlockHashChannelMonitorZ C2Tuple_BlockHashChannelMonitorZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelMonitor b);
+struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_err(struct LDKAPIError e);
 
 /**
- * Frees any resources used by the C2Tuple_BlockHashChannelMonitorZ.
+ * Frees any resources used by the CResult_NoneAPIErrorZ.
  */
-void C2Tuple_BlockHashChannelMonitorZ_free(struct LDKC2Tuple_BlockHashChannelMonitorZ _res);
+void CResult_NoneAPIErrorZ_free(struct LDKCResult_NoneAPIErrorZ _res);
 
 /**
- * Creates a new CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ in the success state.
+ * Creates a new CResult_NoneAPIErrorZ which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelMonitorZ o);
+struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_clone(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ in the error state.
+ * Frees the buffer pointed to by `data` if `datalen` is non-0.
  */
-struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(struct LDKDecodeError e);
+void CVec_CResult_NoneAPIErrorZZ_free(struct LDKCVec_CResult_NoneAPIErrorZZ _res);
 
 /**
- * Frees any resources used by the CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ.
+ * Frees the buffer pointed to by `data` if `datalen` is non-0.
  */
-void CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ _res);
+void CVec_APIErrorZ_free(struct LDKCVec_APIErrorZ _res);
 
 /**
- * Creates a new CResult_RouteHopDecodeErrorZ in the success state.
+ * Creates a new CResult_NonePaymentSendFailureZ in the success state.
  */
-struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_ok(struct LDKRouteHop o);
+struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_ok(void);
 
 /**
- * Creates a new CResult_RouteHopDecodeErrorZ in the error state.
+ * Creates a new CResult_NonePaymentSendFailureZ in the error state.
  */
-struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_err(struct LDKDecodeError e);
+struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
 
 /**
- * Frees any resources used by the CResult_RouteHopDecodeErrorZ.
+ * Frees any resources used by the CResult_NonePaymentSendFailureZ.
  */
-void CResult_RouteHopDecodeErrorZ_free(struct LDKCResult_RouteHopDecodeErrorZ _res);
+void CResult_NonePaymentSendFailureZ_free(struct LDKCResult_NonePaymentSendFailureZ _res);
 
 /**
- * Creates a new CResult_RouteHopDecodeErrorZ which has the same data as `orig`
+ * Creates a new CResult_NonePaymentSendFailureZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_clone(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR orig);
+struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_clone(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR orig);
 
 /**
  * Frees the buffer pointed to by `data` if `datalen` is non-0.
  */
-void CVec_RouteHopZ_free(struct LDKCVec_RouteHopZ _res);
+void CVec_NetAddressZ_free(struct LDKCVec_NetAddressZ _res);
 
 /**
- * Frees the buffer pointed to by `data` if `datalen` is non-0.
+ * Creates a new tuple which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-void CVec_CVec_RouteHopZZ_free(struct LDKCVec_CVec_RouteHopZZ _res);
+struct LDKC2Tuple_PaymentHashPaymentSecretZ C2Tuple_PaymentHashPaymentSecretZ_clone(const struct LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_RouteDecodeErrorZ in the success state.
+ * Creates a new C2Tuple_PaymentHashPaymentSecretZ from the contained elements.
  */
-struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_ok(struct LDKRoute o);
+struct LDKC2Tuple_PaymentHashPaymentSecretZ C2Tuple_PaymentHashPaymentSecretZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
 
 /**
- * Creates a new CResult_RouteDecodeErrorZ in the error state.
+ * Frees any resources used by the C2Tuple_PaymentHashPaymentSecretZ.
  */
-struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_err(struct LDKDecodeError e);
+void C2Tuple_PaymentHashPaymentSecretZ_free(struct LDKC2Tuple_PaymentHashPaymentSecretZ _res);
 
 /**
- * Frees any resources used by the CResult_RouteDecodeErrorZ.
+ * Creates a new CResult_PaymentSecretAPIErrorZ in the success state.
  */
-void CResult_RouteDecodeErrorZ_free(struct LDKCResult_RouteDecodeErrorZ _res);
+struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_ok(struct LDKThirtyTwoBytes o);
 
 /**
- * Creates a new CResult_RouteDecodeErrorZ which has the same data as `orig`
- * but with all dynamically-allocated buffers duplicated in new buffers.
+ * Creates a new CResult_PaymentSecretAPIErrorZ in the error state.
  */
-struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_clone(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR orig);
+struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_err(struct LDKAPIError e);
 
 /**
- * Frees the buffer pointed to by `data` if `datalen` is non-0.
+ * Frees any resources used by the CResult_PaymentSecretAPIErrorZ.
  */
-void CVec_ChannelDetailsZ_free(struct LDKCVec_ChannelDetailsZ _res);
+void CResult_PaymentSecretAPIErrorZ_free(struct LDKCResult_PaymentSecretAPIErrorZ _res);
 
 /**
- * Creates a new CResult_RouteLightningErrorZ in the success state.
+ * Creates a new CResult_PaymentSecretAPIErrorZ which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_ok(struct LDKRoute o);
+struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_clone(const struct LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_RouteLightningErrorZ in the error state.
+ * Frees the buffer pointed to by `data` if `datalen` is non-0.
  */
-struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_err(struct LDKLightningError e);
+void CVec_ChannelMonitorZ_free(struct LDKCVec_ChannelMonitorZ _res);
 
 /**
- * Frees any resources used by the CResult_RouteLightningErrorZ.
+ * Creates a new C2Tuple_BlockHashChannelManagerZ from the contained elements.
  */
-void CResult_RouteLightningErrorZ_free(struct LDKCResult_RouteLightningErrorZ _res);
+struct LDKC2Tuple_BlockHashChannelManagerZ C2Tuple_BlockHashChannelManagerZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelManager b);
 
 /**
- * Creates a new CResult_RouteLightningErrorZ which has the same data as `orig`
- * but with all dynamically-allocated buffers duplicated in new buffers.
+ * Frees any resources used by the C2Tuple_BlockHashChannelManagerZ.
  */
-struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_clone(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR orig);
+void C2Tuple_BlockHashChannelManagerZ_free(struct LDKC2Tuple_BlockHashChannelManagerZ _res);
 
 /**
- * Frees the buffer pointed to by `data` if `datalen` is non-0.
+ * Creates a new CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ in the success state.
  */
-void CVec_MessageSendEventZ_free(struct LDKCVec_MessageSendEventZ _res);
+struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelManagerZ o);
 
 /**
- * Creates a new CResult_boolLightningErrorZ in the success state.
+ * Creates a new CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ in the error state.
  */
-struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_ok(bool o);
+struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Creates a new CResult_boolLightningErrorZ in the error state.
+ * Frees any resources used by the CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ.
  */
-struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_err(struct LDKLightningError e);
+void CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ _res);
 
 /**
- * Frees any resources used by the CResult_boolLightningErrorZ.
+ * Creates a new CResult_ChannelConfigDecodeErrorZ in the success state.
  */
-void CResult_boolLightningErrorZ_free(struct LDKCResult_boolLightningErrorZ _res);
+struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_ok(struct LDKChannelConfig o);
 
 /**
- * Creates a new CResult_boolLightningErrorZ which has the same data as `orig`
- * but with all dynamically-allocated buffers duplicated in new buffers.
+ * Creates a new CResult_ChannelConfigDecodeErrorZ in the error state.
  */
-struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_clone(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR orig);
+struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Creates a new tuple which has the same data as `orig`
- * but with all dynamically-allocated buffers duplicated in new buffers.
+ * Frees any resources used by the CResult_ChannelConfigDecodeErrorZ.
  */
-struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(const struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR orig);
+void CResult_ChannelConfigDecodeErrorZ_free(struct LDKCResult_ChannelConfigDecodeErrorZ _res);
 
 /**
- * Creates a new C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ from the contained elements.
+ * Creates a new CResult_ChannelConfigDecodeErrorZ which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(struct LDKChannelAnnouncement a, struct LDKChannelUpdate b, struct LDKChannelUpdate c);
+struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_clone(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Frees any resources used by the C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ.
+ * Creates a new CResult_OutPointDecodeErrorZ in the success state.
  */
-void C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res);
+struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_ok(struct LDKOutPoint o);
 
 /**
- * Frees the buffer pointed to by `data` if `datalen` is non-0.
+ * Creates a new CResult_OutPointDecodeErrorZ in the error state.
  */
-void CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(struct LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res);
+struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Frees the buffer pointed to by `data` if `datalen` is non-0.
+ * Frees any resources used by the CResult_OutPointDecodeErrorZ.
  */
-void CVec_NodeAnnouncementZ_free(struct LDKCVec_NodeAnnouncementZ _res);
+void CResult_OutPointDecodeErrorZ_free(struct LDKCResult_OutPointDecodeErrorZ _res);
 
 /**
- * Creates a new CResult_NoneLightningErrorZ in the success state.
+ * Creates a new CResult_OutPointDecodeErrorZ which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_ok(void);
+struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_clone(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_NoneLightningErrorZ in the error state.
+ * Creates a new CResult_SiPrefixNoneZ in the success state.
  */
-struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_err(struct LDKLightningError e);
+struct LDKCResult_SiPrefixNoneZ CResult_SiPrefixNoneZ_ok(enum LDKSiPrefix o);
 
 /**
- * Frees any resources used by the CResult_NoneLightningErrorZ.
+ * Creates a new CResult_SiPrefixNoneZ in the error state.
  */
-void CResult_NoneLightningErrorZ_free(struct LDKCResult_NoneLightningErrorZ _res);
+struct LDKCResult_SiPrefixNoneZ CResult_SiPrefixNoneZ_err(void);
 
 /**
- * Creates a new CResult_NoneLightningErrorZ which has the same data as `orig`
- * but with all dynamically-allocated buffers duplicated in new buffers.
+ * Frees any resources used by the CResult_SiPrefixNoneZ.
  */
-struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_clone(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR orig);
+void CResult_SiPrefixNoneZ_free(struct LDKCResult_SiPrefixNoneZ _res);
 
 /**
- * Frees the buffer pointed to by `data` if `datalen` is non-0.
+ * Creates a new CResult_SiPrefixNoneZ which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-void CVec_PublicKeyZ_free(struct LDKCVec_PublicKeyZ _res);
+struct LDKCResult_SiPrefixNoneZ CResult_SiPrefixNoneZ_clone(const struct LDKCResult_SiPrefixNoneZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_CVec_u8ZPeerHandleErrorZ in the success state.
+ * Creates a new CResult_InvoiceNoneZ in the success state.
  */
-struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_ok(struct LDKCVec_u8Z o);
+struct LDKCResult_InvoiceNoneZ CResult_InvoiceNoneZ_ok(struct LDKInvoice o);
 
 /**
- * Creates a new CResult_CVec_u8ZPeerHandleErrorZ in the error state.
+ * Creates a new CResult_InvoiceNoneZ in the error state.
  */
-struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_err(struct LDKPeerHandleError e);
+struct LDKCResult_InvoiceNoneZ CResult_InvoiceNoneZ_err(void);
 
 /**
- * Frees any resources used by the CResult_CVec_u8ZPeerHandleErrorZ.
+ * Frees any resources used by the CResult_InvoiceNoneZ.
  */
-void CResult_CVec_u8ZPeerHandleErrorZ_free(struct LDKCResult_CVec_u8ZPeerHandleErrorZ _res);
+void CResult_InvoiceNoneZ_free(struct LDKCResult_InvoiceNoneZ _res);
 
 /**
- * Creates a new CResult_CVec_u8ZPeerHandleErrorZ which has the same data as `orig`
+ * Creates a new CResult_InvoiceNoneZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_clone(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR orig);
+struct LDKCResult_InvoiceNoneZ CResult_InvoiceNoneZ_clone(const struct LDKCResult_InvoiceNoneZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_NonePeerHandleErrorZ in the success state.
+ * Creates a new CResult_SignedRawInvoiceNoneZ in the success state.
  */
-struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_ok(void);
+struct LDKCResult_SignedRawInvoiceNoneZ CResult_SignedRawInvoiceNoneZ_ok(struct LDKSignedRawInvoice o);
 
 /**
- * Creates a new CResult_NonePeerHandleErrorZ in the error state.
+ * Creates a new CResult_SignedRawInvoiceNoneZ in the error state.
  */
-struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_err(struct LDKPeerHandleError e);
+struct LDKCResult_SignedRawInvoiceNoneZ CResult_SignedRawInvoiceNoneZ_err(void);
 
 /**
- * Frees any resources used by the CResult_NonePeerHandleErrorZ.
+ * Frees any resources used by the CResult_SignedRawInvoiceNoneZ.
  */
-void CResult_NonePeerHandleErrorZ_free(struct LDKCResult_NonePeerHandleErrorZ _res);
+void CResult_SignedRawInvoiceNoneZ_free(struct LDKCResult_SignedRawInvoiceNoneZ _res);
 
 /**
- * Creates a new CResult_NonePeerHandleErrorZ which has the same data as `orig`
+ * Creates a new CResult_SignedRawInvoiceNoneZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_clone(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR orig);
+struct LDKCResult_SignedRawInvoiceNoneZ CResult_SignedRawInvoiceNoneZ_clone(const struct LDKCResult_SignedRawInvoiceNoneZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_boolPeerHandleErrorZ in the success state.
+ * Creates a new tuple which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_ok(bool o);
+struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(const struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_boolPeerHandleErrorZ in the error state.
+ * Creates a new C3Tuple_RawInvoice_u832InvoiceSignatureZ from the contained elements.
  */
-struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_err(struct LDKPeerHandleError e);
+struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(struct LDKRawInvoice a, struct LDKThirtyTwoBytes b, struct LDKInvoiceSignature c);
 
 /**
- * Frees any resources used by the CResult_boolPeerHandleErrorZ.
+ * Frees any resources used by the C3Tuple_RawInvoice_u832InvoiceSignatureZ.
  */
-void CResult_boolPeerHandleErrorZ_free(struct LDKCResult_boolPeerHandleErrorZ _res);
+void C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ _res);
 
 /**
- * Creates a new CResult_boolPeerHandleErrorZ which has the same data as `orig`
- * but with all dynamically-allocated buffers duplicated in new buffers.
+ * Creates a new CResult_PayeePubKeyErrorZ in the success state.
  */
-struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_clone(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR orig);
+struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_ok(struct LDKPayeePubKey o);
 
 /**
- * Creates a new CResult_TxOutAccessErrorZ in the success state.
+ * Creates a new CResult_PayeePubKeyErrorZ in the error state.
  */
-struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_ok(struct LDKTxOut o);
+struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_err(enum LDKSecp256k1Error e);
 
 /**
- * Creates a new CResult_TxOutAccessErrorZ in the error state.
+ * Frees any resources used by the CResult_PayeePubKeyErrorZ.
  */
-struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_err(enum LDKAccessError e);
+void CResult_PayeePubKeyErrorZ_free(struct LDKCResult_PayeePubKeyErrorZ _res);
 
 /**
- * Frees any resources used by the CResult_TxOutAccessErrorZ.
+ * Creates a new CResult_PayeePubKeyErrorZ which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-void CResult_TxOutAccessErrorZ_free(struct LDKCResult_TxOutAccessErrorZ _res);
+struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_clone(const struct LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_TxOutAccessErrorZ which has the same data as `orig`
- * but with all dynamically-allocated buffers duplicated in new buffers.
+ * Frees the buffer pointed to by `data` if `datalen` is non-0.
  */
-struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_clone(const struct LDKCResult_TxOutAccessErrorZ *NONNULL_PTR orig);
+void CVec_RouteHintZ_free(struct LDKCVec_RouteHintZ _res);
 
 /**
- * Constructs a new COption_C2Tuple_usizeTransactionZZ containing a crate::c_types::derived::C2Tuple_usizeTransactionZ
+ * Creates a new CResult_PositiveTimestampCreationErrorZ in the success state.
  */
-struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_some(struct LDKC2Tuple_usizeTransactionZ o);
+struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_ok(struct LDKPositiveTimestamp o);
 
 /**
- * Constructs a new COption_C2Tuple_usizeTransactionZZ containing nothing
+ * Creates a new CResult_PositiveTimestampCreationErrorZ in the error state.
  */
-struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_none(void);
+struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_err(enum LDKCreationError e);
 
 /**
- * Frees any resources associated with the crate::c_types::derived::C2Tuple_usizeTransactionZ, if we are in the Some state
+ * Frees any resources used by the CResult_PositiveTimestampCreationErrorZ.
  */
-void COption_C2Tuple_usizeTransactionZZ_free(struct LDKCOption_C2Tuple_usizeTransactionZZ _res);
+void CResult_PositiveTimestampCreationErrorZ_free(struct LDKCResult_PositiveTimestampCreationErrorZ _res);
 
 /**
- * Frees the buffer pointed to by `data` if `datalen` is non-0.
+ * Creates a new CResult_PositiveTimestampCreationErrorZ which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-void CVec_SpendableOutputDescriptorZ_free(struct LDKCVec_SpendableOutputDescriptorZ _res);
+struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_clone(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_DirectionalChannelInfoDecodeErrorZ in the success state.
+ * Creates a new CResult_NoneSemanticErrorZ in the success state.
  */
-struct LDKCResult_DirectionalChannelInfoDecodeErrorZ CResult_DirectionalChannelInfoDecodeErrorZ_ok(struct LDKDirectionalChannelInfo o);
+struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_ok(void);
 
 /**
- * Creates a new CResult_DirectionalChannelInfoDecodeErrorZ in the error state.
+ * Creates a new CResult_NoneSemanticErrorZ in the error state.
  */
-struct LDKCResult_DirectionalChannelInfoDecodeErrorZ CResult_DirectionalChannelInfoDecodeErrorZ_err(struct LDKDecodeError e);
+struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_err(enum LDKSemanticError e);
 
 /**
- * Frees any resources used by the CResult_DirectionalChannelInfoDecodeErrorZ.
+ * Frees any resources used by the CResult_NoneSemanticErrorZ.
  */
-void CResult_DirectionalChannelInfoDecodeErrorZ_free(struct LDKCResult_DirectionalChannelInfoDecodeErrorZ _res);
+void CResult_NoneSemanticErrorZ_free(struct LDKCResult_NoneSemanticErrorZ _res);
 
 /**
- * Creates a new CResult_DirectionalChannelInfoDecodeErrorZ which has the same data as `orig`
+ * Creates a new CResult_NoneSemanticErrorZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_DirectionalChannelInfoDecodeErrorZ CResult_DirectionalChannelInfoDecodeErrorZ_clone(const struct LDKCResult_DirectionalChannelInfoDecodeErrorZ *NONNULL_PTR orig);
+struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_clone(const struct LDKCResult_NoneSemanticErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_ChannelInfoDecodeErrorZ in the success state.
+ * Creates a new CResult_InvoiceSemanticErrorZ in the success state.
  */
-struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_ok(struct LDKChannelInfo o);
+struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_ok(struct LDKInvoice o);
 
 /**
- * Creates a new CResult_ChannelInfoDecodeErrorZ in the error state.
+ * Creates a new CResult_InvoiceSemanticErrorZ in the error state.
  */
-struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_err(struct LDKDecodeError e);
+struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_err(enum LDKSemanticError e);
 
 /**
- * Frees any resources used by the CResult_ChannelInfoDecodeErrorZ.
+ * Frees any resources used by the CResult_InvoiceSemanticErrorZ.
  */
-void CResult_ChannelInfoDecodeErrorZ_free(struct LDKCResult_ChannelInfoDecodeErrorZ _res);
+void CResult_InvoiceSemanticErrorZ_free(struct LDKCResult_InvoiceSemanticErrorZ _res);
 
 /**
- * Creates a new CResult_ChannelInfoDecodeErrorZ which has the same data as `orig`
+ * Creates a new CResult_InvoiceSemanticErrorZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR orig);
-
-/**
- * Creates a new CResult_RoutingFeesDecodeErrorZ in the success state.
- */
-struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_ok(struct LDKRoutingFees o);
+struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_clone(const struct LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_RoutingFeesDecodeErrorZ in the error state.
+ * Creates a new CResult_DescriptionCreationErrorZ in the success state.
  */
-struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_err(struct LDKDecodeError e);
+struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_ok(struct LDKDescription o);
 
 /**
- * Frees any resources used by the CResult_RoutingFeesDecodeErrorZ.
+ * Creates a new CResult_DescriptionCreationErrorZ in the error state.
  */
-void CResult_RoutingFeesDecodeErrorZ_free(struct LDKCResult_RoutingFeesDecodeErrorZ _res);
+struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_err(enum LDKCreationError e);
 
 /**
- * Creates a new CResult_RoutingFeesDecodeErrorZ which has the same data as `orig`
- * but with all dynamically-allocated buffers duplicated in new buffers.
+ * Frees any resources used by the CResult_DescriptionCreationErrorZ.
  */
-struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_clone(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR orig);
+void CResult_DescriptionCreationErrorZ_free(struct LDKCResult_DescriptionCreationErrorZ _res);
 
 /**
- * Frees the buffer pointed to by `data` if `datalen` is non-0.
+ * Creates a new CResult_DescriptionCreationErrorZ which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-void CVec_NetAddressZ_free(struct LDKCVec_NetAddressZ _res);
+struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_clone(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_NodeAnnouncementInfoDecodeErrorZ in the success state.
+ * Creates a new CResult_ExpiryTimeCreationErrorZ in the success state.
  */
-struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_ok(struct LDKNodeAnnouncementInfo o);
+struct LDKCResult_ExpiryTimeCreationErrorZ CResult_ExpiryTimeCreationErrorZ_ok(struct LDKExpiryTime o);
 
 /**
- * Creates a new CResult_NodeAnnouncementInfoDecodeErrorZ in the error state.
+ * Creates a new CResult_ExpiryTimeCreationErrorZ in the error state.
  */
-struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_err(struct LDKDecodeError e);
+struct LDKCResult_ExpiryTimeCreationErrorZ CResult_ExpiryTimeCreationErrorZ_err(enum LDKCreationError e);
 
 /**
- * Frees any resources used by the CResult_NodeAnnouncementInfoDecodeErrorZ.
+ * Frees any resources used by the CResult_ExpiryTimeCreationErrorZ.
  */
-void CResult_NodeAnnouncementInfoDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ _res);
+void CResult_ExpiryTimeCreationErrorZ_free(struct LDKCResult_ExpiryTimeCreationErrorZ _res);
 
 /**
- * Creates a new CResult_NodeAnnouncementInfoDecodeErrorZ which has the same data as `orig`
+ * Creates a new CResult_ExpiryTimeCreationErrorZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR orig);
+struct LDKCResult_ExpiryTimeCreationErrorZ CResult_ExpiryTimeCreationErrorZ_clone(const struct LDKCResult_ExpiryTimeCreationErrorZ *NONNULL_PTR orig);
 
 /**
- * Frees the buffer pointed to by `data` if `datalen` is non-0.
+ * Creates a new CResult_RouteHintCreationErrorZ in the success state.
  */
-void CVec_u64Z_free(struct LDKCVec_u64Z _res);
+struct LDKCResult_RouteHintCreationErrorZ CResult_RouteHintCreationErrorZ_ok(struct LDKRouteHint o);
 
 /**
- * Creates a new CResult_NodeInfoDecodeErrorZ in the success state.
+ * Creates a new CResult_RouteHintCreationErrorZ in the error state.
  */
-struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_ok(struct LDKNodeInfo o);
+struct LDKCResult_RouteHintCreationErrorZ CResult_RouteHintCreationErrorZ_err(enum LDKCreationError e);
 
 /**
- * Creates a new CResult_NodeInfoDecodeErrorZ in the error state.
+ * Frees any resources used by the CResult_RouteHintCreationErrorZ.
  */
-struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_err(struct LDKDecodeError e);
+void CResult_RouteHintCreationErrorZ_free(struct LDKCResult_RouteHintCreationErrorZ _res);
 
 /**
- * Frees any resources used by the CResult_NodeInfoDecodeErrorZ.
+ * Creates a new CResult_RouteHintCreationErrorZ which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-void CResult_NodeInfoDecodeErrorZ_free(struct LDKCResult_NodeInfoDecodeErrorZ _res);
+struct LDKCResult_RouteHintCreationErrorZ CResult_RouteHintCreationErrorZ_clone(const struct LDKCResult_RouteHintCreationErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_NodeInfoDecodeErrorZ which has the same data as `orig`
- * but with all dynamically-allocated buffers duplicated in new buffers.
+ * Creates a new CResult_StringErrorZ in the success state.
  */
-struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_clone(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR orig);
+struct LDKCResult_StringErrorZ CResult_StringErrorZ_ok(struct LDKStr o);
 
 /**
- * Creates a new CResult_NetworkGraphDecodeErrorZ in the success state.
+ * Creates a new CResult_StringErrorZ in the error state.
  */
-struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_ok(struct LDKNetworkGraph o);
+struct LDKCResult_StringErrorZ CResult_StringErrorZ_err(enum LDKSecp256k1Error e);
 
 /**
- * Creates a new CResult_NetworkGraphDecodeErrorZ in the error state.
+ * Frees any resources used by the CResult_StringErrorZ.
  */
-struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_err(struct LDKDecodeError e);
+void CResult_StringErrorZ_free(struct LDKCResult_StringErrorZ _res);
 
 /**
- * Frees any resources used by the CResult_NetworkGraphDecodeErrorZ.
+ * Creates a new CResult_ChannelMonitorUpdateDecodeErrorZ in the success state.
  */
-void CResult_NetworkGraphDecodeErrorZ_free(struct LDKCResult_NetworkGraphDecodeErrorZ _res);
+struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_ok(struct LDKChannelMonitorUpdate o);
 
 /**
- * Creates a new CResult_NetworkGraphDecodeErrorZ which has the same data as `orig`
- * but with all dynamically-allocated buffers duplicated in new buffers.
+ * Creates a new CResult_ChannelMonitorUpdateDecodeErrorZ in the error state.
  */
-struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_clone(const struct LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR orig);
+struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Creates a new CResult_InitFeaturesDecodeErrorZ in the success state.
+ * Frees any resources used by the CResult_ChannelMonitorUpdateDecodeErrorZ.
  */
-struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_ok(struct LDKInitFeatures o);
+void CResult_ChannelMonitorUpdateDecodeErrorZ_free(struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ _res);
 
 /**
- * Creates a new CResult_InitFeaturesDecodeErrorZ in the error state.
+ * Creates a new CResult_ChannelMonitorUpdateDecodeErrorZ which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
+struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Frees any resources used by the CResult_InitFeaturesDecodeErrorZ.
+ * Creates a new CResult_HTLCUpdateDecodeErrorZ in the success state.
  */
-void CResult_InitFeaturesDecodeErrorZ_free(struct LDKCResult_InitFeaturesDecodeErrorZ _res);
+struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_ok(struct LDKHTLCUpdate o);
 
 /**
- * Creates a new CResult_NodeFeaturesDecodeErrorZ in the success state.
+ * Creates a new CResult_HTLCUpdateDecodeErrorZ in the error state.
  */
-struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_ok(struct LDKNodeFeatures o);
+struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Creates a new CResult_NodeFeaturesDecodeErrorZ in the error state.
+ * Frees any resources used by the CResult_HTLCUpdateDecodeErrorZ.
  */
-struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
+void CResult_HTLCUpdateDecodeErrorZ_free(struct LDKCResult_HTLCUpdateDecodeErrorZ _res);
 
 /**
- * Frees any resources used by the CResult_NodeFeaturesDecodeErrorZ.
+ * Creates a new CResult_HTLCUpdateDecodeErrorZ which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-void CResult_NodeFeaturesDecodeErrorZ_free(struct LDKCResult_NodeFeaturesDecodeErrorZ _res);
+struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_clone(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_ChannelFeaturesDecodeErrorZ in the success state.
+ * Creates a new CResult_NoneMonitorUpdateErrorZ in the success state.
  */
-struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_ok(struct LDKChannelFeatures o);
+struct LDKCResult_NoneMonitorUpdateErrorZ CResult_NoneMonitorUpdateErrorZ_ok(void);
 
 /**
- * Creates a new CResult_ChannelFeaturesDecodeErrorZ in the error state.
+ * Creates a new CResult_NoneMonitorUpdateErrorZ in the error state.
  */
-struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
+struct LDKCResult_NoneMonitorUpdateErrorZ CResult_NoneMonitorUpdateErrorZ_err(struct LDKMonitorUpdateError e);
 
 /**
- * Frees any resources used by the CResult_ChannelFeaturesDecodeErrorZ.
+ * Frees any resources used by the CResult_NoneMonitorUpdateErrorZ.
  */
-void CResult_ChannelFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelFeaturesDecodeErrorZ _res);
+void CResult_NoneMonitorUpdateErrorZ_free(struct LDKCResult_NoneMonitorUpdateErrorZ _res);
 
 /**
- * Creates a new CResult_InvoiceFeaturesDecodeErrorZ in the success state.
+ * Creates a new CResult_NoneMonitorUpdateErrorZ which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_ok(struct LDKInvoiceFeatures o);
+struct LDKCResult_NoneMonitorUpdateErrorZ CResult_NoneMonitorUpdateErrorZ_clone(const struct LDKCResult_NoneMonitorUpdateErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_InvoiceFeaturesDecodeErrorZ in the error state.
+ * Creates a new tuple which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
+struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_clone(const struct LDKC2Tuple_OutPointScriptZ *NONNULL_PTR orig);
 
 /**
- * Frees any resources used by the CResult_InvoiceFeaturesDecodeErrorZ.
+ * Creates a new C2Tuple_OutPointScriptZ from the contained elements.
  */
-void CResult_InvoiceFeaturesDecodeErrorZ_free(struct LDKCResult_InvoiceFeaturesDecodeErrorZ _res);
+struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_new(struct LDKOutPoint a, struct LDKCVec_u8Z b);
 
 /**
- * Creates a new CResult_NetAddressu8Z in the success state.
+ * Frees any resources used by the C2Tuple_OutPointScriptZ.
  */
-struct LDKCResult_NetAddressu8Z CResult_NetAddressu8Z_ok(struct LDKNetAddress o);
+void C2Tuple_OutPointScriptZ_free(struct LDKC2Tuple_OutPointScriptZ _res);
 
 /**
- * Creates a new CResult_NetAddressu8Z in the error state.
+ * Creates a new tuple which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_NetAddressu8Z CResult_NetAddressu8Z_err(uint8_t e);
+struct LDKC2Tuple_u32ScriptZ C2Tuple_u32ScriptZ_clone(const struct LDKC2Tuple_u32ScriptZ *NONNULL_PTR orig);
 
 /**
- * Frees any resources used by the CResult_NetAddressu8Z.
+ * Creates a new C2Tuple_u32ScriptZ from the contained elements.
  */
-void CResult_NetAddressu8Z_free(struct LDKCResult_NetAddressu8Z _res);
+struct LDKC2Tuple_u32ScriptZ C2Tuple_u32ScriptZ_new(uint32_t a, struct LDKCVec_u8Z b);
 
 /**
- * Creates a new CResult_NetAddressu8Z which has the same data as `orig`
- * but with all dynamically-allocated buffers duplicated in new buffers.
+ * Frees any resources used by the C2Tuple_u32ScriptZ.
  */
-struct LDKCResult_NetAddressu8Z CResult_NetAddressu8Z_clone(const struct LDKCResult_NetAddressu8Z *NONNULL_PTR orig);
+void C2Tuple_u32ScriptZ_free(struct LDKC2Tuple_u32ScriptZ _res);
 
 /**
- * Creates a new CResult_CResult_NetAddressu8ZDecodeErrorZ in the success state.
+ * Frees the buffer pointed to by `data` if `datalen` is non-0.
  */
-struct LDKCResult_CResult_NetAddressu8ZDecodeErrorZ CResult_CResult_NetAddressu8ZDecodeErrorZ_ok(struct LDKCResult_NetAddressu8Z o);
+void CVec_C2Tuple_u32ScriptZZ_free(struct LDKCVec_C2Tuple_u32ScriptZZ _res);
 
 /**
- * Creates a new CResult_CResult_NetAddressu8ZDecodeErrorZ in the error state.
+ * Creates a new tuple which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_CResult_NetAddressu8ZDecodeErrorZ CResult_CResult_NetAddressu8ZDecodeErrorZ_err(struct LDKDecodeError e);
+struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(const struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR orig);
 
 /**
- * Frees any resources used by the CResult_CResult_NetAddressu8ZDecodeErrorZ.
+ * Creates a new C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ from the contained elements.
  */
-void CResult_CResult_NetAddressu8ZDecodeErrorZ_free(struct LDKCResult_CResult_NetAddressu8ZDecodeErrorZ _res);
+struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32ScriptZZ b);
 
 /**
- * Creates a new CResult_CResult_NetAddressu8ZDecodeErrorZ which has the same data as `orig`
- * but with all dynamically-allocated buffers duplicated in new buffers.
+ * Frees any resources used by the C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ.
  */
-struct LDKCResult_CResult_NetAddressu8ZDecodeErrorZ CResult_CResult_NetAddressu8ZDecodeErrorZ_clone(const struct LDKCResult_CResult_NetAddressu8ZDecodeErrorZ *NONNULL_PTR orig);
+void C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ _res);
 
 /**
- * Creates a new CResult_NetAddressDecodeErrorZ in the success state.
+ * Frees the buffer pointed to by `data` if `datalen` is non-0.
  */
-struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_ok(struct LDKNetAddress o);
+void CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ _res);
 
 /**
- * Creates a new CResult_NetAddressDecodeErrorZ in the error state.
+ * Frees the buffer pointed to by `data` if `datalen` is non-0.
  */
-struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_err(struct LDKDecodeError e);
+void CVec_EventZ_free(struct LDKCVec_EventZ _res);
 
 /**
- * Frees any resources used by the CResult_NetAddressDecodeErrorZ.
+ * Frees the buffer pointed to by `data` if `datalen` is non-0.
  */
-void CResult_NetAddressDecodeErrorZ_free(struct LDKCResult_NetAddressDecodeErrorZ _res);
+void CVec_TransactionZ_free(struct LDKCVec_TransactionZ _res);
 
 /**
- * Creates a new CResult_NetAddressDecodeErrorZ which has the same data as `orig`
+ * Creates a new tuple which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_clone(const struct LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR orig);
+struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_clone(const struct LDKC2Tuple_u32TxOutZ *NONNULL_PTR orig);
 
 /**
- * Frees the buffer pointed to by `data` if `datalen` is non-0.
+ * Creates a new C2Tuple_u32TxOutZ from the contained elements.
  */
-void CVec_UpdateAddHTLCZ_free(struct LDKCVec_UpdateAddHTLCZ _res);
+struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_new(uint32_t a, struct LDKTxOut b);
 
 /**
- * Frees the buffer pointed to by `data` if `datalen` is non-0.
+ * Frees any resources used by the C2Tuple_u32TxOutZ.
  */
-void CVec_UpdateFulfillHTLCZ_free(struct LDKCVec_UpdateFulfillHTLCZ _res);
+void C2Tuple_u32TxOutZ_free(struct LDKC2Tuple_u32TxOutZ _res);
 
 /**
  * Frees the buffer pointed to by `data` if `datalen` is non-0.
  */
-void CVec_UpdateFailHTLCZ_free(struct LDKCVec_UpdateFailHTLCZ _res);
+void CVec_C2Tuple_u32TxOutZZ_free(struct LDKCVec_C2Tuple_u32TxOutZZ _res);
 
 /**
- * Frees the buffer pointed to by `data` if `datalen` is non-0.
+ * Creates a new tuple which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-void CVec_UpdateFailMalformedHTLCZ_free(struct LDKCVec_UpdateFailMalformedHTLCZ _res);
+struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(const struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_AcceptChannelDecodeErrorZ in the success state.
+ * Creates a new C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ from the contained elements.
  */
-struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_ok(struct LDKAcceptChannel o);
+struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32TxOutZZ b);
 
 /**
- * Creates a new CResult_AcceptChannelDecodeErrorZ in the error state.
+ * Frees any resources used by the C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ.
  */
-struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_err(struct LDKDecodeError e);
+void C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ _res);
 
 /**
- * Frees any resources used by the CResult_AcceptChannelDecodeErrorZ.
+ * Frees the buffer pointed to by `data` if `datalen` is non-0.
  */
-void CResult_AcceptChannelDecodeErrorZ_free(struct LDKCResult_AcceptChannelDecodeErrorZ _res);
+void CVec_TransactionOutputsZ_free(struct LDKCVec_TransactionOutputsZ _res);
 
 /**
- * Creates a new CResult_AcceptChannelDecodeErrorZ which has the same data as `orig`
- * but with all dynamically-allocated buffers duplicated in new buffers.
+ * Creates a new CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ in the success state.
  */
-struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_clone(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR orig);
+struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelMonitorZ o);
 
 /**
- * Creates a new CResult_AnnouncementSignaturesDecodeErrorZ in the success state.
+ * Creates a new CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ in the error state.
  */
-struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_ok(struct LDKAnnouncementSignatures o);
+struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Creates a new CResult_AnnouncementSignaturesDecodeErrorZ in the error state.
+ * Frees any resources used by the CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ.
  */
-struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_err(struct LDKDecodeError e);
+void CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ _res);
 
 /**
- * Frees any resources used by the CResult_AnnouncementSignaturesDecodeErrorZ.
+ * Creates a new CResult_boolLightningErrorZ in the success state.
  */
-void CResult_AnnouncementSignaturesDecodeErrorZ_free(struct LDKCResult_AnnouncementSignaturesDecodeErrorZ _res);
+struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_ok(bool o);
 
 /**
- * Creates a new CResult_AnnouncementSignaturesDecodeErrorZ which has the same data as `orig`
- * but with all dynamically-allocated buffers duplicated in new buffers.
+ * Creates a new CResult_boolLightningErrorZ in the error state.
  */
-struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_clone(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR orig);
+struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_err(struct LDKLightningError e);
 
 /**
- * Creates a new CResult_ChannelReestablishDecodeErrorZ in the success state.
+ * Frees any resources used by the CResult_boolLightningErrorZ.
  */
-struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_ok(struct LDKChannelReestablish o);
+void CResult_boolLightningErrorZ_free(struct LDKCResult_boolLightningErrorZ _res);
 
 /**
- * Creates a new CResult_ChannelReestablishDecodeErrorZ in the error state.
+ * Creates a new CResult_boolLightningErrorZ which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_err(struct LDKDecodeError e);
+struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_clone(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR orig);
 
 /**
- * Frees any resources used by the CResult_ChannelReestablishDecodeErrorZ.
+ * Creates a new tuple which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-void CResult_ChannelReestablishDecodeErrorZ_free(struct LDKCResult_ChannelReestablishDecodeErrorZ _res);
+struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(const struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_ChannelReestablishDecodeErrorZ which has the same data as `orig`
- * but with all dynamically-allocated buffers duplicated in new buffers.
+ * Creates a new C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ from the contained elements.
  */
-struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_clone(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR orig);
+struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(struct LDKChannelAnnouncement a, struct LDKChannelUpdate b, struct LDKChannelUpdate c);
 
 /**
- * Creates a new CResult_ClosingSignedDecodeErrorZ in the success state.
+ * Frees any resources used by the C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ.
  */
-struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_ok(struct LDKClosingSigned o);
+void C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res);
 
 /**
- * Creates a new CResult_ClosingSignedDecodeErrorZ in the error state.
+ * Frees the buffer pointed to by `data` if `datalen` is non-0.
  */
-struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_err(struct LDKDecodeError e);
+void CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(struct LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res);
 
 /**
- * Frees any resources used by the CResult_ClosingSignedDecodeErrorZ.
+ * Frees the buffer pointed to by `data` if `datalen` is non-0.
  */
-void CResult_ClosingSignedDecodeErrorZ_free(struct LDKCResult_ClosingSignedDecodeErrorZ _res);
+void CVec_NodeAnnouncementZ_free(struct LDKCVec_NodeAnnouncementZ _res);
 
 /**
- * Creates a new CResult_ClosingSignedDecodeErrorZ which has the same data as `orig`
- * but with all dynamically-allocated buffers duplicated in new buffers.
+ * Creates a new CResult_NoneLightningErrorZ in the success state.
  */
-struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR orig);
+struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_ok(void);
 
 /**
- * Creates a new CResult_CommitmentSignedDecodeErrorZ in the success state.
+ * Creates a new CResult_NoneLightningErrorZ in the error state.
  */
-struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_ok(struct LDKCommitmentSigned o);
+struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_err(struct LDKLightningError e);
 
 /**
- * Creates a new CResult_CommitmentSignedDecodeErrorZ in the error state.
+ * Frees any resources used by the CResult_NoneLightningErrorZ.
  */
-struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_err(struct LDKDecodeError e);
+void CResult_NoneLightningErrorZ_free(struct LDKCResult_NoneLightningErrorZ _res);
 
 /**
- * Frees any resources used by the CResult_CommitmentSignedDecodeErrorZ.
+ * Creates a new CResult_NoneLightningErrorZ which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-void CResult_CommitmentSignedDecodeErrorZ_free(struct LDKCResult_CommitmentSignedDecodeErrorZ _res);
+struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_clone(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_CommitmentSignedDecodeErrorZ which has the same data as `orig`
- * but with all dynamically-allocated buffers duplicated in new buffers.
+ * Frees the buffer pointed to by `data` if `datalen` is non-0.
  */
-struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_clone(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR orig);
+void CVec_PublicKeyZ_free(struct LDKCVec_PublicKeyZ _res);
 
 /**
- * Creates a new CResult_FundingCreatedDecodeErrorZ in the success state.
+ * Creates a new CResult_CVec_u8ZPeerHandleErrorZ in the success state.
  */
-struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_ok(struct LDKFundingCreated o);
+struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_ok(struct LDKCVec_u8Z o);
 
 /**
- * Creates a new CResult_FundingCreatedDecodeErrorZ in the error state.
+ * Creates a new CResult_CVec_u8ZPeerHandleErrorZ in the error state.
  */
-struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_err(struct LDKDecodeError e);
+struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_err(struct LDKPeerHandleError e);
 
 /**
- * Frees any resources used by the CResult_FundingCreatedDecodeErrorZ.
+ * Frees any resources used by the CResult_CVec_u8ZPeerHandleErrorZ.
  */
-void CResult_FundingCreatedDecodeErrorZ_free(struct LDKCResult_FundingCreatedDecodeErrorZ _res);
+void CResult_CVec_u8ZPeerHandleErrorZ_free(struct LDKCResult_CVec_u8ZPeerHandleErrorZ _res);
 
 /**
- * Creates a new CResult_FundingCreatedDecodeErrorZ which has the same data as `orig`
+ * Creates a new CResult_CVec_u8ZPeerHandleErrorZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_clone(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR orig);
+struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_clone(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_FundingSignedDecodeErrorZ in the success state.
+ * Creates a new CResult_NonePeerHandleErrorZ in the success state.
  */
-struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_ok(struct LDKFundingSigned o);
+struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_ok(void);
 
 /**
- * Creates a new CResult_FundingSignedDecodeErrorZ in the error state.
+ * Creates a new CResult_NonePeerHandleErrorZ in the error state.
  */
-struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_err(struct LDKDecodeError e);
+struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_err(struct LDKPeerHandleError e);
 
 /**
- * Frees any resources used by the CResult_FundingSignedDecodeErrorZ.
+ * Frees any resources used by the CResult_NonePeerHandleErrorZ.
  */
-void CResult_FundingSignedDecodeErrorZ_free(struct LDKCResult_FundingSignedDecodeErrorZ _res);
+void CResult_NonePeerHandleErrorZ_free(struct LDKCResult_NonePeerHandleErrorZ _res);
 
 /**
- * Creates a new CResult_FundingSignedDecodeErrorZ which has the same data as `orig`
+ * Creates a new CResult_NonePeerHandleErrorZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_clone(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR orig);
+struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_clone(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_FundingLockedDecodeErrorZ in the success state.
+ * Creates a new CResult_boolPeerHandleErrorZ in the success state.
  */
-struct LDKCResult_FundingLockedDecodeErrorZ CResult_FundingLockedDecodeErrorZ_ok(struct LDKFundingLocked o);
+struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_ok(bool o);
 
 /**
- * Creates a new CResult_FundingLockedDecodeErrorZ in the error state.
+ * Creates a new CResult_boolPeerHandleErrorZ in the error state.
  */
-struct LDKCResult_FundingLockedDecodeErrorZ CResult_FundingLockedDecodeErrorZ_err(struct LDKDecodeError e);
+struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_err(struct LDKPeerHandleError e);
 
 /**
- * Frees any resources used by the CResult_FundingLockedDecodeErrorZ.
+ * Frees any resources used by the CResult_boolPeerHandleErrorZ.
  */
-void CResult_FundingLockedDecodeErrorZ_free(struct LDKCResult_FundingLockedDecodeErrorZ _res);
+void CResult_boolPeerHandleErrorZ_free(struct LDKCResult_boolPeerHandleErrorZ _res);
 
 /**
- * Creates a new CResult_FundingLockedDecodeErrorZ which has the same data as `orig`
+ * Creates a new CResult_boolPeerHandleErrorZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_FundingLockedDecodeErrorZ CResult_FundingLockedDecodeErrorZ_clone(const struct LDKCResult_FundingLockedDecodeErrorZ *NONNULL_PTR orig);
+struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_clone(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_InitDecodeErrorZ in the success state.
+ * Creates a new CResult_DirectionalChannelInfoDecodeErrorZ in the success state.
  */
-struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_ok(struct LDKInit o);
+struct LDKCResult_DirectionalChannelInfoDecodeErrorZ CResult_DirectionalChannelInfoDecodeErrorZ_ok(struct LDKDirectionalChannelInfo o);
 
 /**
- * Creates a new CResult_InitDecodeErrorZ in the error state.
+ * Creates a new CResult_DirectionalChannelInfoDecodeErrorZ in the error state.
  */
-struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_err(struct LDKDecodeError e);
+struct LDKCResult_DirectionalChannelInfoDecodeErrorZ CResult_DirectionalChannelInfoDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Frees any resources used by the CResult_InitDecodeErrorZ.
+ * Frees any resources used by the CResult_DirectionalChannelInfoDecodeErrorZ.
  */
-void CResult_InitDecodeErrorZ_free(struct LDKCResult_InitDecodeErrorZ _res);
+void CResult_DirectionalChannelInfoDecodeErrorZ_free(struct LDKCResult_DirectionalChannelInfoDecodeErrorZ _res);
 
 /**
- * Creates a new CResult_InitDecodeErrorZ which has the same data as `orig`
+ * Creates a new CResult_DirectionalChannelInfoDecodeErrorZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_clone(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR orig);
+struct LDKCResult_DirectionalChannelInfoDecodeErrorZ CResult_DirectionalChannelInfoDecodeErrorZ_clone(const struct LDKCResult_DirectionalChannelInfoDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_OpenChannelDecodeErrorZ in the success state.
+ * Creates a new CResult_ChannelInfoDecodeErrorZ in the success state.
  */
-struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_ok(struct LDKOpenChannel o);
+struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_ok(struct LDKChannelInfo o);
 
 /**
- * Creates a new CResult_OpenChannelDecodeErrorZ in the error state.
+ * Creates a new CResult_ChannelInfoDecodeErrorZ in the error state.
  */
-struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_err(struct LDKDecodeError e);
+struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Frees any resources used by the CResult_OpenChannelDecodeErrorZ.
+ * Frees any resources used by the CResult_ChannelInfoDecodeErrorZ.
  */
-void CResult_OpenChannelDecodeErrorZ_free(struct LDKCResult_OpenChannelDecodeErrorZ _res);
+void CResult_ChannelInfoDecodeErrorZ_free(struct LDKCResult_ChannelInfoDecodeErrorZ _res);
 
 /**
- * Creates a new CResult_OpenChannelDecodeErrorZ which has the same data as `orig`
+ * Creates a new CResult_ChannelInfoDecodeErrorZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_clone(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR orig);
+struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_RevokeAndACKDecodeErrorZ in the success state.
+ * Creates a new CResult_RoutingFeesDecodeErrorZ in the success state.
  */
-struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_ok(struct LDKRevokeAndACK o);
+struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_ok(struct LDKRoutingFees o);
 
 /**
- * Creates a new CResult_RevokeAndACKDecodeErrorZ in the error state.
+ * Creates a new CResult_RoutingFeesDecodeErrorZ in the error state.
  */
-struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_err(struct LDKDecodeError e);
+struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Frees any resources used by the CResult_RevokeAndACKDecodeErrorZ.
+ * Frees any resources used by the CResult_RoutingFeesDecodeErrorZ.
  */
-void CResult_RevokeAndACKDecodeErrorZ_free(struct LDKCResult_RevokeAndACKDecodeErrorZ _res);
+void CResult_RoutingFeesDecodeErrorZ_free(struct LDKCResult_RoutingFeesDecodeErrorZ _res);
 
 /**
- * Creates a new CResult_RevokeAndACKDecodeErrorZ which has the same data as `orig`
+ * Creates a new CResult_RoutingFeesDecodeErrorZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_clone(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR orig);
+struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_clone(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_ShutdownDecodeErrorZ in the success state.
+ * Creates a new CResult_NodeAnnouncementInfoDecodeErrorZ in the success state.
  */
-struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_ok(struct LDKShutdown o);
+struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_ok(struct LDKNodeAnnouncementInfo o);
 
 /**
- * Creates a new CResult_ShutdownDecodeErrorZ in the error state.
+ * Creates a new CResult_NodeAnnouncementInfoDecodeErrorZ in the error state.
  */
-struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_err(struct LDKDecodeError e);
+struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Frees any resources used by the CResult_ShutdownDecodeErrorZ.
+ * Frees any resources used by the CResult_NodeAnnouncementInfoDecodeErrorZ.
  */
-void CResult_ShutdownDecodeErrorZ_free(struct LDKCResult_ShutdownDecodeErrorZ _res);
+void CResult_NodeAnnouncementInfoDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ _res);
 
 /**
- * Creates a new CResult_ShutdownDecodeErrorZ which has the same data as `orig`
+ * Creates a new CResult_NodeAnnouncementInfoDecodeErrorZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_clone(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR orig);
+struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_UpdateFailHTLCDecodeErrorZ in the success state.
+ * Frees the buffer pointed to by `data` if `datalen` is non-0.
  */
-struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_ok(struct LDKUpdateFailHTLC o);
+void CVec_u64Z_free(struct LDKCVec_u64Z _res);
 
 /**
- * Creates a new CResult_UpdateFailHTLCDecodeErrorZ in the error state.
+ * Creates a new CResult_NodeInfoDecodeErrorZ in the success state.
  */
-struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_err(struct LDKDecodeError e);
+struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_ok(struct LDKNodeInfo o);
 
 /**
- * Frees any resources used by the CResult_UpdateFailHTLCDecodeErrorZ.
+ * Creates a new CResult_NodeInfoDecodeErrorZ in the error state.
  */
-void CResult_UpdateFailHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailHTLCDecodeErrorZ _res);
+struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Creates a new CResult_UpdateFailHTLCDecodeErrorZ which has the same data as `orig`
+ * Frees any resources used by the CResult_NodeInfoDecodeErrorZ.
+ */
+void CResult_NodeInfoDecodeErrorZ_free(struct LDKCResult_NodeInfoDecodeErrorZ _res);
+
+/**
+ * Creates a new CResult_NodeInfoDecodeErrorZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR orig);
+struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_clone(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_UpdateFailMalformedHTLCDecodeErrorZ in the success state.
+ * Creates a new CResult_NetworkGraphDecodeErrorZ in the success state.
  */
-struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(struct LDKUpdateFailMalformedHTLC o);
+struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_ok(struct LDKNetworkGraph o);
 
 /**
- * Creates a new CResult_UpdateFailMalformedHTLCDecodeErrorZ in the error state.
+ * Creates a new CResult_NetworkGraphDecodeErrorZ in the error state.
  */
-struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(struct LDKDecodeError e);
+struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Frees any resources used by the CResult_UpdateFailMalformedHTLCDecodeErrorZ.
+ * Frees any resources used by the CResult_NetworkGraphDecodeErrorZ.
  */
-void CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ _res);
+void CResult_NetworkGraphDecodeErrorZ_free(struct LDKCResult_NetworkGraphDecodeErrorZ _res);
 
 /**
- * Creates a new CResult_UpdateFailMalformedHTLCDecodeErrorZ which has the same data as `orig`
+ * Creates a new CResult_NetworkGraphDecodeErrorZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR orig);
+struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_clone(const struct LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_UpdateFeeDecodeErrorZ in the success state.
+ * Creates a new CResult_NetAddressu8Z in the success state.
  */
-struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_ok(struct LDKUpdateFee o);
+struct LDKCResult_NetAddressu8Z CResult_NetAddressu8Z_ok(struct LDKNetAddress o);
 
 /**
- * Creates a new CResult_UpdateFeeDecodeErrorZ in the error state.
+ * Creates a new CResult_NetAddressu8Z in the error state.
  */
-struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_err(struct LDKDecodeError e);
+struct LDKCResult_NetAddressu8Z CResult_NetAddressu8Z_err(uint8_t e);
 
 /**
- * Frees any resources used by the CResult_UpdateFeeDecodeErrorZ.
+ * Frees any resources used by the CResult_NetAddressu8Z.
  */
-void CResult_UpdateFeeDecodeErrorZ_free(struct LDKCResult_UpdateFeeDecodeErrorZ _res);
+void CResult_NetAddressu8Z_free(struct LDKCResult_NetAddressu8Z _res);
 
 /**
- * Creates a new CResult_UpdateFeeDecodeErrorZ which has the same data as `orig`
+ * Creates a new CResult_NetAddressu8Z which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_clone(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR orig);
+struct LDKCResult_NetAddressu8Z CResult_NetAddressu8Z_clone(const struct LDKCResult_NetAddressu8Z *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_UpdateFulfillHTLCDecodeErrorZ in the success state.
+ * Creates a new CResult_CResult_NetAddressu8ZDecodeErrorZ in the success state.
  */
-struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_ok(struct LDKUpdateFulfillHTLC o);
+struct LDKCResult_CResult_NetAddressu8ZDecodeErrorZ CResult_CResult_NetAddressu8ZDecodeErrorZ_ok(struct LDKCResult_NetAddressu8Z o);
 
 /**
- * Creates a new CResult_UpdateFulfillHTLCDecodeErrorZ in the error state.
+ * Creates a new CResult_CResult_NetAddressu8ZDecodeErrorZ in the error state.
  */
-struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_err(struct LDKDecodeError e);
+struct LDKCResult_CResult_NetAddressu8ZDecodeErrorZ CResult_CResult_NetAddressu8ZDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Frees any resources used by the CResult_UpdateFulfillHTLCDecodeErrorZ.
+ * Frees any resources used by the CResult_CResult_NetAddressu8ZDecodeErrorZ.
  */
-void CResult_UpdateFulfillHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ _res);
+void CResult_CResult_NetAddressu8ZDecodeErrorZ_free(struct LDKCResult_CResult_NetAddressu8ZDecodeErrorZ _res);
 
 /**
- * Creates a new CResult_UpdateFulfillHTLCDecodeErrorZ which has the same data as `orig`
+ * Creates a new CResult_CResult_NetAddressu8ZDecodeErrorZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR orig);
+struct LDKCResult_CResult_NetAddressu8ZDecodeErrorZ CResult_CResult_NetAddressu8ZDecodeErrorZ_clone(const struct LDKCResult_CResult_NetAddressu8ZDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_UpdateAddHTLCDecodeErrorZ in the success state.
+ * Creates a new CResult_NetAddressDecodeErrorZ in the success state.
  */
-struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_ok(struct LDKUpdateAddHTLC o);
+struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_ok(struct LDKNetAddress o);
 
 /**
- * Creates a new CResult_UpdateAddHTLCDecodeErrorZ in the error state.
+ * Creates a new CResult_NetAddressDecodeErrorZ in the error state.
  */
-struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_err(struct LDKDecodeError e);
+struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Frees any resources used by the CResult_UpdateAddHTLCDecodeErrorZ.
+ * Frees any resources used by the CResult_NetAddressDecodeErrorZ.
  */
-void CResult_UpdateAddHTLCDecodeErrorZ_free(struct LDKCResult_UpdateAddHTLCDecodeErrorZ _res);
+void CResult_NetAddressDecodeErrorZ_free(struct LDKCResult_NetAddressDecodeErrorZ _res);
 
 /**
- * Creates a new CResult_UpdateAddHTLCDecodeErrorZ which has the same data as `orig`
+ * Creates a new CResult_NetAddressDecodeErrorZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR orig);
+struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_clone(const struct LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_PingDecodeErrorZ in the success state.
+ * Frees the buffer pointed to by `data` if `datalen` is non-0.
  */
-struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_ok(struct LDKPing o);
+void CVec_UpdateAddHTLCZ_free(struct LDKCVec_UpdateAddHTLCZ _res);
 
 /**
- * Creates a new CResult_PingDecodeErrorZ in the error state.
+ * Frees the buffer pointed to by `data` if `datalen` is non-0.
  */
-struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_err(struct LDKDecodeError e);
+void CVec_UpdateFulfillHTLCZ_free(struct LDKCVec_UpdateFulfillHTLCZ _res);
 
 /**
- * Frees any resources used by the CResult_PingDecodeErrorZ.
+ * Frees the buffer pointed to by `data` if `datalen` is non-0.
  */
-void CResult_PingDecodeErrorZ_free(struct LDKCResult_PingDecodeErrorZ _res);
+void CVec_UpdateFailHTLCZ_free(struct LDKCVec_UpdateFailHTLCZ _res);
 
 /**
- * Creates a new CResult_PingDecodeErrorZ which has the same data as `orig`
- * but with all dynamically-allocated buffers duplicated in new buffers.
+ * Frees the buffer pointed to by `data` if `datalen` is non-0.
  */
-struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_clone(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR orig);
+void CVec_UpdateFailMalformedHTLCZ_free(struct LDKCVec_UpdateFailMalformedHTLCZ _res);
 
 /**
- * Creates a new CResult_PongDecodeErrorZ in the success state.
+ * Creates a new CResult_AcceptChannelDecodeErrorZ in the success state.
  */
-struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_ok(struct LDKPong o);
+struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_ok(struct LDKAcceptChannel o);
 
 /**
- * Creates a new CResult_PongDecodeErrorZ in the error state.
+ * Creates a new CResult_AcceptChannelDecodeErrorZ in the error state.
  */
-struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_err(struct LDKDecodeError e);
+struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Frees any resources used by the CResult_PongDecodeErrorZ.
+ * Frees any resources used by the CResult_AcceptChannelDecodeErrorZ.
  */
-void CResult_PongDecodeErrorZ_free(struct LDKCResult_PongDecodeErrorZ _res);
+void CResult_AcceptChannelDecodeErrorZ_free(struct LDKCResult_AcceptChannelDecodeErrorZ _res);
 
 /**
- * Creates a new CResult_PongDecodeErrorZ which has the same data as `orig`
+ * Creates a new CResult_AcceptChannelDecodeErrorZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_clone(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR orig);
+struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_clone(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_UnsignedChannelAnnouncementDecodeErrorZ in the success state.
+ * Creates a new CResult_AnnouncementSignaturesDecodeErrorZ in the success state.
  */
-struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(struct LDKUnsignedChannelAnnouncement o);
+struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_ok(struct LDKAnnouncementSignatures o);
 
 /**
- * Creates a new CResult_UnsignedChannelAnnouncementDecodeErrorZ in the error state.
+ * Creates a new CResult_AnnouncementSignaturesDecodeErrorZ in the error state.
  */
-struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
+struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Frees any resources used by the CResult_UnsignedChannelAnnouncementDecodeErrorZ.
+ * Frees any resources used by the CResult_AnnouncementSignaturesDecodeErrorZ.
  */
-void CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ _res);
+void CResult_AnnouncementSignaturesDecodeErrorZ_free(struct LDKCResult_AnnouncementSignaturesDecodeErrorZ _res);
 
 /**
- * Creates a new CResult_UnsignedChannelAnnouncementDecodeErrorZ which has the same data as `orig`
+ * Creates a new CResult_AnnouncementSignaturesDecodeErrorZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
+struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_clone(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_ChannelAnnouncementDecodeErrorZ in the success state.
+ * Creates a new CResult_ChannelReestablishDecodeErrorZ in the success state.
  */
-struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_ok(struct LDKChannelAnnouncement o);
+struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_ok(struct LDKChannelReestablish o);
 
 /**
- * Creates a new CResult_ChannelAnnouncementDecodeErrorZ in the error state.
+ * Creates a new CResult_ChannelReestablishDecodeErrorZ in the error state.
  */
-struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
+struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Frees any resources used by the CResult_ChannelAnnouncementDecodeErrorZ.
+ * Frees any resources used by the CResult_ChannelReestablishDecodeErrorZ.
  */
-void CResult_ChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_ChannelAnnouncementDecodeErrorZ _res);
+void CResult_ChannelReestablishDecodeErrorZ_free(struct LDKCResult_ChannelReestablishDecodeErrorZ _res);
 
 /**
- * Creates a new CResult_ChannelAnnouncementDecodeErrorZ which has the same data as `orig`
+ * Creates a new CResult_ChannelReestablishDecodeErrorZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
+struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_clone(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_UnsignedChannelUpdateDecodeErrorZ in the success state.
+ * Creates a new CResult_ClosingSignedDecodeErrorZ in the success state.
  */
-struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_ok(struct LDKUnsignedChannelUpdate o);
+struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_ok(struct LDKClosingSigned o);
 
 /**
- * Creates a new CResult_UnsignedChannelUpdateDecodeErrorZ in the error state.
+ * Creates a new CResult_ClosingSignedDecodeErrorZ in the error state.
  */
-struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
+struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Frees any resources used by the CResult_UnsignedChannelUpdateDecodeErrorZ.
+ * Frees any resources used by the CResult_ClosingSignedDecodeErrorZ.
  */
-void CResult_UnsignedChannelUpdateDecodeErrorZ_free(struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ _res);
+void CResult_ClosingSignedDecodeErrorZ_free(struct LDKCResult_ClosingSignedDecodeErrorZ _res);
 
 /**
- * Creates a new CResult_UnsignedChannelUpdateDecodeErrorZ which has the same data as `orig`
+ * Creates a new CResult_ClosingSignedDecodeErrorZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
+struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_ChannelUpdateDecodeErrorZ in the success state.
+ * Creates a new CResult_CommitmentSignedDecodeErrorZ in the success state.
  */
-struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_ok(struct LDKChannelUpdate o);
+struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_ok(struct LDKCommitmentSigned o);
 
 /**
- * Creates a new CResult_ChannelUpdateDecodeErrorZ in the error state.
+ * Creates a new CResult_CommitmentSignedDecodeErrorZ in the error state.
  */
-struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
+struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Frees any resources used by the CResult_ChannelUpdateDecodeErrorZ.
+ * Frees any resources used by the CResult_CommitmentSignedDecodeErrorZ.
  */
-void CResult_ChannelUpdateDecodeErrorZ_free(struct LDKCResult_ChannelUpdateDecodeErrorZ _res);
+void CResult_CommitmentSignedDecodeErrorZ_free(struct LDKCResult_CommitmentSignedDecodeErrorZ _res);
 
 /**
- * Creates a new CResult_ChannelUpdateDecodeErrorZ which has the same data as `orig`
+ * Creates a new CResult_CommitmentSignedDecodeErrorZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
+struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_clone(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_ErrorMessageDecodeErrorZ in the success state.
+ * Creates a new CResult_FundingCreatedDecodeErrorZ in the success state.
  */
-struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_ok(struct LDKErrorMessage o);
+struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_ok(struct LDKFundingCreated o);
 
 /**
- * Creates a new CResult_ErrorMessageDecodeErrorZ in the error state.
+ * Creates a new CResult_FundingCreatedDecodeErrorZ in the error state.
  */
-struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_err(struct LDKDecodeError e);
+struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Frees any resources used by the CResult_ErrorMessageDecodeErrorZ.
+ * Frees any resources used by the CResult_FundingCreatedDecodeErrorZ.
  */
-void CResult_ErrorMessageDecodeErrorZ_free(struct LDKCResult_ErrorMessageDecodeErrorZ _res);
+void CResult_FundingCreatedDecodeErrorZ_free(struct LDKCResult_FundingCreatedDecodeErrorZ _res);
 
 /**
- * Creates a new CResult_ErrorMessageDecodeErrorZ which has the same data as `orig`
+ * Creates a new CResult_FundingCreatedDecodeErrorZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_clone(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR orig);
+struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_clone(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_UnsignedNodeAnnouncementDecodeErrorZ in the success state.
+ * Creates a new CResult_FundingSignedDecodeErrorZ in the success state.
  */
-struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(struct LDKUnsignedNodeAnnouncement o);
+struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_ok(struct LDKFundingSigned o);
 
 /**
- * Creates a new CResult_UnsignedNodeAnnouncementDecodeErrorZ in the error state.
+ * Creates a new CResult_FundingSignedDecodeErrorZ in the error state.
  */
-struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
+struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Frees any resources used by the CResult_UnsignedNodeAnnouncementDecodeErrorZ.
+ * Frees any resources used by the CResult_FundingSignedDecodeErrorZ.
  */
-void CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ _res);
+void CResult_FundingSignedDecodeErrorZ_free(struct LDKCResult_FundingSignedDecodeErrorZ _res);
 
 /**
- * Creates a new CResult_UnsignedNodeAnnouncementDecodeErrorZ which has the same data as `orig`
+ * Creates a new CResult_FundingSignedDecodeErrorZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
+struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_clone(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_NodeAnnouncementDecodeErrorZ in the success state.
+ * Creates a new CResult_FundingLockedDecodeErrorZ in the success state.
  */
-struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_ok(struct LDKNodeAnnouncement o);
+struct LDKCResult_FundingLockedDecodeErrorZ CResult_FundingLockedDecodeErrorZ_ok(struct LDKFundingLocked o);
 
 /**
- * Creates a new CResult_NodeAnnouncementDecodeErrorZ in the error state.
+ * Creates a new CResult_FundingLockedDecodeErrorZ in the error state.
  */
-struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
+struct LDKCResult_FundingLockedDecodeErrorZ CResult_FundingLockedDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Frees any resources used by the CResult_NodeAnnouncementDecodeErrorZ.
+ * Frees any resources used by the CResult_FundingLockedDecodeErrorZ.
  */
-void CResult_NodeAnnouncementDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementDecodeErrorZ _res);
+void CResult_FundingLockedDecodeErrorZ_free(struct LDKCResult_FundingLockedDecodeErrorZ _res);
 
 /**
- * Creates a new CResult_NodeAnnouncementDecodeErrorZ which has the same data as `orig`
+ * Creates a new CResult_FundingLockedDecodeErrorZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
+struct LDKCResult_FundingLockedDecodeErrorZ CResult_FundingLockedDecodeErrorZ_clone(const struct LDKCResult_FundingLockedDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_QueryShortChannelIdsDecodeErrorZ in the success state.
+ * Creates a new CResult_InitDecodeErrorZ in the success state.
  */
-struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_ok(struct LDKQueryShortChannelIds o);
+struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_ok(struct LDKInit o);
 
 /**
- * Creates a new CResult_QueryShortChannelIdsDecodeErrorZ in the error state.
+ * Creates a new CResult_InitDecodeErrorZ in the error state.
  */
-struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_err(struct LDKDecodeError e);
+struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Frees any resources used by the CResult_QueryShortChannelIdsDecodeErrorZ.
+ * Frees any resources used by the CResult_InitDecodeErrorZ.
  */
-void CResult_QueryShortChannelIdsDecodeErrorZ_free(struct LDKCResult_QueryShortChannelIdsDecodeErrorZ _res);
+void CResult_InitDecodeErrorZ_free(struct LDKCResult_InitDecodeErrorZ _res);
 
 /**
- * Creates a new CResult_QueryShortChannelIdsDecodeErrorZ which has the same data as `orig`
+ * Creates a new CResult_InitDecodeErrorZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_clone(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR orig);
+struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_clone(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_ReplyShortChannelIdsEndDecodeErrorZ in the success state.
+ * Creates a new CResult_OpenChannelDecodeErrorZ in the success state.
  */
-struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(struct LDKReplyShortChannelIdsEnd o);
+struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_ok(struct LDKOpenChannel o);
 
 /**
- * Creates a new CResult_ReplyShortChannelIdsEndDecodeErrorZ in the error state.
+ * Creates a new CResult_OpenChannelDecodeErrorZ in the error state.
  */
-struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(struct LDKDecodeError e);
+struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Frees any resources used by the CResult_ReplyShortChannelIdsEndDecodeErrorZ.
+ * Frees any resources used by the CResult_OpenChannelDecodeErrorZ.
  */
-void CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ _res);
+void CResult_OpenChannelDecodeErrorZ_free(struct LDKCResult_OpenChannelDecodeErrorZ _res);
 
 /**
- * Creates a new CResult_ReplyShortChannelIdsEndDecodeErrorZ which has the same data as `orig`
+ * Creates a new CResult_OpenChannelDecodeErrorZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR orig);
+struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_clone(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_QueryChannelRangeDecodeErrorZ in the success state.
+ * Creates a new CResult_RevokeAndACKDecodeErrorZ in the success state.
  */
-struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_ok(struct LDKQueryChannelRange o);
+struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_ok(struct LDKRevokeAndACK o);
 
 /**
- * Creates a new CResult_QueryChannelRangeDecodeErrorZ in the error state.
+ * Creates a new CResult_RevokeAndACKDecodeErrorZ in the error state.
  */
-struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
+struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Frees any resources used by the CResult_QueryChannelRangeDecodeErrorZ.
+ * Frees any resources used by the CResult_RevokeAndACKDecodeErrorZ.
  */
-void CResult_QueryChannelRangeDecodeErrorZ_free(struct LDKCResult_QueryChannelRangeDecodeErrorZ _res);
+void CResult_RevokeAndACKDecodeErrorZ_free(struct LDKCResult_RevokeAndACKDecodeErrorZ _res);
 
 /**
- * Creates a new CResult_QueryChannelRangeDecodeErrorZ which has the same data as `orig`
+ * Creates a new CResult_RevokeAndACKDecodeErrorZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_clone(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR orig);
+struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_clone(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_ReplyChannelRangeDecodeErrorZ in the success state.
+ * Creates a new CResult_ShutdownDecodeErrorZ in the success state.
  */
-struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_ok(struct LDKReplyChannelRange o);
+struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_ok(struct LDKShutdown o);
 
 /**
- * Creates a new CResult_ReplyChannelRangeDecodeErrorZ in the error state.
+ * Creates a new CResult_ShutdownDecodeErrorZ in the error state.
  */
-struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
+struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Frees any resources used by the CResult_ReplyChannelRangeDecodeErrorZ.
+ * Frees any resources used by the CResult_ShutdownDecodeErrorZ.
  */
-void CResult_ReplyChannelRangeDecodeErrorZ_free(struct LDKCResult_ReplyChannelRangeDecodeErrorZ _res);
+void CResult_ShutdownDecodeErrorZ_free(struct LDKCResult_ShutdownDecodeErrorZ _res);
 
 /**
- * Creates a new CResult_ReplyChannelRangeDecodeErrorZ which has the same data as `orig`
+ * Creates a new CResult_ShutdownDecodeErrorZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_clone(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR orig);
+struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_clone(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_GossipTimestampFilterDecodeErrorZ in the success state.
+ * Creates a new CResult_UpdateFailHTLCDecodeErrorZ in the success state.
  */
-struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_ok(struct LDKGossipTimestampFilter o);
+struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_ok(struct LDKUpdateFailHTLC o);
 
 /**
- * Creates a new CResult_GossipTimestampFilterDecodeErrorZ in the error state.
+ * Creates a new CResult_UpdateFailHTLCDecodeErrorZ in the error state.
  */
-struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_err(struct LDKDecodeError e);
+struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Frees any resources used by the CResult_GossipTimestampFilterDecodeErrorZ.
+ * Frees any resources used by the CResult_UpdateFailHTLCDecodeErrorZ.
  */
-void CResult_GossipTimestampFilterDecodeErrorZ_free(struct LDKCResult_GossipTimestampFilterDecodeErrorZ _res);
+void CResult_UpdateFailHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailHTLCDecodeErrorZ _res);
 
 /**
- * Creates a new CResult_GossipTimestampFilterDecodeErrorZ which has the same data as `orig`
+ * Creates a new CResult_UpdateFailHTLCDecodeErrorZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_clone(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR orig);
+struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_InvoiceSignOrCreationErrorZ in the success state.
+ * Creates a new CResult_UpdateFailMalformedHTLCDecodeErrorZ in the success state.
  */
-struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_ok(struct LDKInvoice o);
+struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(struct LDKUpdateFailMalformedHTLC o);
 
 /**
- * Creates a new CResult_InvoiceSignOrCreationErrorZ in the error state.
+ * Creates a new CResult_UpdateFailMalformedHTLCDecodeErrorZ in the error state.
  */
-struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_err(struct LDKSignOrCreationError e);
+struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Frees any resources used by the CResult_InvoiceSignOrCreationErrorZ.
+ * Frees any resources used by the CResult_UpdateFailMalformedHTLCDecodeErrorZ.
  */
-void CResult_InvoiceSignOrCreationErrorZ_free(struct LDKCResult_InvoiceSignOrCreationErrorZ _res);
+void CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ _res);
 
 /**
- * Creates a new CResult_InvoiceSignOrCreationErrorZ which has the same data as `orig`
+ * Creates a new CResult_UpdateFailMalformedHTLCDecodeErrorZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_clone(const struct LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR orig);
+struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_DelayedPaymentOutputDescriptorDecodeErrorZ in the success state.
+ * Creates a new CResult_UpdateFeeDecodeErrorZ in the success state.
  */
-struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKDelayedPaymentOutputDescriptor o);
+struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_ok(struct LDKUpdateFee o);
 
 /**
- * Creates a new CResult_DelayedPaymentOutputDescriptorDecodeErrorZ in the error state.
+ * Creates a new CResult_UpdateFeeDecodeErrorZ in the error state.
  */
-struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
+struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Frees any resources used by the CResult_DelayedPaymentOutputDescriptorDecodeErrorZ.
+ * Frees any resources used by the CResult_UpdateFeeDecodeErrorZ.
  */
-void CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ _res);
+void CResult_UpdateFeeDecodeErrorZ_free(struct LDKCResult_UpdateFeeDecodeErrorZ _res);
 
 /**
- * Creates a new CResult_DelayedPaymentOutputDescriptorDecodeErrorZ which has the same data as `orig`
+ * Creates a new CResult_UpdateFeeDecodeErrorZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
+struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_clone(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_StaticPaymentOutputDescriptorDecodeErrorZ in the success state.
+ * Creates a new CResult_UpdateFulfillHTLCDecodeErrorZ in the success state.
  */
-struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKStaticPaymentOutputDescriptor o);
+struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_ok(struct LDKUpdateFulfillHTLC o);
 
 /**
- * Creates a new CResult_StaticPaymentOutputDescriptorDecodeErrorZ in the error state.
+ * Creates a new CResult_UpdateFulfillHTLCDecodeErrorZ in the error state.
  */
-struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
+struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Frees any resources used by the CResult_StaticPaymentOutputDescriptorDecodeErrorZ.
+ * Frees any resources used by the CResult_UpdateFulfillHTLCDecodeErrorZ.
  */
-void CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ _res);
+void CResult_UpdateFulfillHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ _res);
 
 /**
- * Creates a new CResult_StaticPaymentOutputDescriptorDecodeErrorZ which has the same data as `orig`
+ * Creates a new CResult_UpdateFulfillHTLCDecodeErrorZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
+struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_SpendableOutputDescriptorDecodeErrorZ in the success state.
+ * Creates a new CResult_UpdateAddHTLCDecodeErrorZ in the success state.
  */
-struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_ok(struct LDKSpendableOutputDescriptor o);
+struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_ok(struct LDKUpdateAddHTLC o);
 
 /**
- * Creates a new CResult_SpendableOutputDescriptorDecodeErrorZ in the error state.
+ * Creates a new CResult_UpdateAddHTLCDecodeErrorZ in the error state.
  */
-struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
+struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Frees any resources used by the CResult_SpendableOutputDescriptorDecodeErrorZ.
+ * Frees any resources used by the CResult_UpdateAddHTLCDecodeErrorZ.
  */
-void CResult_SpendableOutputDescriptorDecodeErrorZ_free(struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ _res);
+void CResult_UpdateAddHTLCDecodeErrorZ_free(struct LDKCResult_UpdateAddHTLCDecodeErrorZ _res);
 
 /**
- * Creates a new CResult_SpendableOutputDescriptorDecodeErrorZ which has the same data as `orig`
+ * Creates a new CResult_UpdateAddHTLCDecodeErrorZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
+struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new tuple which has the same data as `orig`
- * but with all dynamically-allocated buffers duplicated in new buffers.
+ * Creates a new CResult_PingDecodeErrorZ in the success state.
  */
-struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_clone(const struct LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR orig);
+struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_ok(struct LDKPing o);
 
 /**
- * Creates a new C2Tuple_SignatureCVec_SignatureZZ from the contained elements.
+ * Creates a new CResult_PingDecodeErrorZ in the error state.
  */
-struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_new(struct LDKSignature a, struct LDKCVec_SignatureZ b);
+struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Frees any resources used by the C2Tuple_SignatureCVec_SignatureZZ.
+ * Frees any resources used by the CResult_PingDecodeErrorZ.
  */
-void C2Tuple_SignatureCVec_SignatureZZ_free(struct LDKC2Tuple_SignatureCVec_SignatureZZ _res);
+void CResult_PingDecodeErrorZ_free(struct LDKCResult_PingDecodeErrorZ _res);
+
+/**
+ * Creates a new CResult_PingDecodeErrorZ which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
+ */
+struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_clone(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ in the success state.
+ * Creates a new CResult_PongDecodeErrorZ in the success state.
  */
-struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(struct LDKC2Tuple_SignatureCVec_SignatureZZ o);
+struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_ok(struct LDKPong o);
 
 /**
- * Creates a new CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ in the error state.
+ * Creates a new CResult_PongDecodeErrorZ in the error state.
  */
-struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(void);
+struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Frees any resources used by the CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ.
+ * Frees any resources used by the CResult_PongDecodeErrorZ.
  */
-void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ _res);
+void CResult_PongDecodeErrorZ_free(struct LDKCResult_PongDecodeErrorZ _res);
 
 /**
- * Creates a new CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ which has the same data as `orig`
+ * Creates a new CResult_PongDecodeErrorZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(const struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR orig);
+struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_clone(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_SignatureNoneZ in the success state.
+ * Creates a new CResult_UnsignedChannelAnnouncementDecodeErrorZ in the success state.
  */
-struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_ok(struct LDKSignature o);
+struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(struct LDKUnsignedChannelAnnouncement o);
 
 /**
- * Creates a new CResult_SignatureNoneZ in the error state.
+ * Creates a new CResult_UnsignedChannelAnnouncementDecodeErrorZ in the error state.
  */
-struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_err(void);
+struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Frees any resources used by the CResult_SignatureNoneZ.
+ * Frees any resources used by the CResult_UnsignedChannelAnnouncementDecodeErrorZ.
  */
-void CResult_SignatureNoneZ_free(struct LDKCResult_SignatureNoneZ _res);
+void CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ _res);
 
 /**
- * Creates a new CResult_SignatureNoneZ which has the same data as `orig`
+ * Creates a new CResult_UnsignedChannelAnnouncementDecodeErrorZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_clone(const struct LDKCResult_SignatureNoneZ *NONNULL_PTR orig);
+struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_SignDecodeErrorZ in the success state.
+ * Creates a new CResult_ChannelAnnouncementDecodeErrorZ in the success state.
  */
-struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_ok(struct LDKSign o);
+struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_ok(struct LDKChannelAnnouncement o);
 
 /**
- * Creates a new CResult_SignDecodeErrorZ in the error state.
+ * Creates a new CResult_ChannelAnnouncementDecodeErrorZ in the error state.
  */
-struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_err(struct LDKDecodeError e);
+struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Frees any resources used by the CResult_SignDecodeErrorZ.
+ * Frees any resources used by the CResult_ChannelAnnouncementDecodeErrorZ.
  */
-void CResult_SignDecodeErrorZ_free(struct LDKCResult_SignDecodeErrorZ _res);
+void CResult_ChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_ChannelAnnouncementDecodeErrorZ _res);
 
 /**
- * Creates a new CResult_SignDecodeErrorZ which has the same data as `orig`
+ * Creates a new CResult_ChannelAnnouncementDecodeErrorZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_clone(const struct LDKCResult_SignDecodeErrorZ *NONNULL_PTR orig);
+struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_RecoverableSignatureNoneZ in the success state.
+ * Creates a new CResult_UnsignedChannelUpdateDecodeErrorZ in the success state.
  */
-struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_ok(struct LDKRecoverableSignature o);
+struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_ok(struct LDKUnsignedChannelUpdate o);
 
 /**
- * Creates a new CResult_RecoverableSignatureNoneZ in the error state.
+ * Creates a new CResult_UnsignedChannelUpdateDecodeErrorZ in the error state.
  */
-struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_err(void);
+struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Frees any resources used by the CResult_RecoverableSignatureNoneZ.
+ * Frees any resources used by the CResult_UnsignedChannelUpdateDecodeErrorZ.
  */
-void CResult_RecoverableSignatureNoneZ_free(struct LDKCResult_RecoverableSignatureNoneZ _res);
+void CResult_UnsignedChannelUpdateDecodeErrorZ_free(struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ _res);
 
 /**
- * Creates a new CResult_RecoverableSignatureNoneZ which has the same data as `orig`
+ * Creates a new CResult_UnsignedChannelUpdateDecodeErrorZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_clone(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR orig);
-
-/**
- * Frees the buffer pointed to by `data` if `datalen` is non-0.
- */
-void CVec_CVec_u8ZZ_free(struct LDKCVec_CVec_u8ZZ _res);
+struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_CVec_CVec_u8ZZNoneZ in the success state.
+ * Creates a new CResult_ChannelUpdateDecodeErrorZ in the success state.
  */
-struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_ok(struct LDKCVec_CVec_u8ZZ o);
+struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_ok(struct LDKChannelUpdate o);
 
 /**
- * Creates a new CResult_CVec_CVec_u8ZZNoneZ in the error state.
+ * Creates a new CResult_ChannelUpdateDecodeErrorZ in the error state.
  */
-struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_err(void);
+struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Frees any resources used by the CResult_CVec_CVec_u8ZZNoneZ.
+ * Frees any resources used by the CResult_ChannelUpdateDecodeErrorZ.
  */
-void CResult_CVec_CVec_u8ZZNoneZ_free(struct LDKCResult_CVec_CVec_u8ZZNoneZ _res);
+void CResult_ChannelUpdateDecodeErrorZ_free(struct LDKCResult_ChannelUpdateDecodeErrorZ _res);
 
 /**
- * Creates a new CResult_CVec_CVec_u8ZZNoneZ which has the same data as `orig`
+ * Creates a new CResult_ChannelUpdateDecodeErrorZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_clone(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR orig);
+struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_InMemorySignerDecodeErrorZ in the success state.
+ * Creates a new CResult_ErrorMessageDecodeErrorZ in the success state.
  */
-struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_ok(struct LDKInMemorySigner o);
+struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_ok(struct LDKErrorMessage o);
 
 /**
- * Creates a new CResult_InMemorySignerDecodeErrorZ in the error state.
+ * Creates a new CResult_ErrorMessageDecodeErrorZ in the error state.
  */
-struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_err(struct LDKDecodeError e);
+struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Frees any resources used by the CResult_InMemorySignerDecodeErrorZ.
+ * Frees any resources used by the CResult_ErrorMessageDecodeErrorZ.
  */
-void CResult_InMemorySignerDecodeErrorZ_free(struct LDKCResult_InMemorySignerDecodeErrorZ _res);
+void CResult_ErrorMessageDecodeErrorZ_free(struct LDKCResult_ErrorMessageDecodeErrorZ _res);
 
 /**
- * Creates a new CResult_InMemorySignerDecodeErrorZ which has the same data as `orig`
+ * Creates a new CResult_ErrorMessageDecodeErrorZ which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_clone(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR orig);
+struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_clone(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Frees the buffer pointed to by `data` if `datalen` is non-0.
+ * Creates a new CResult_UnsignedNodeAnnouncementDecodeErrorZ in the success state.
  */
-void CVec_TxOutZ_free(struct LDKCVec_TxOutZ _res);
+struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(struct LDKUnsignedNodeAnnouncement o);
 
 /**
- * Creates a new CResult_TransactionNoneZ in the success state.
+ * Creates a new CResult_UnsignedNodeAnnouncementDecodeErrorZ in the error state.
  */
-struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_ok(struct LDKTransaction o);
+struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Creates a new CResult_TransactionNoneZ in the error state.
+ * Frees any resources used by the CResult_UnsignedNodeAnnouncementDecodeErrorZ.
  */
-struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_err(void);
+void CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ _res);
 
 /**
- * Frees any resources used by the CResult_TransactionNoneZ.
+ * Creates a new CResult_UnsignedNodeAnnouncementDecodeErrorZ which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-void CResult_TransactionNoneZ_free(struct LDKCResult_TransactionNoneZ _res);
+struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_NoneErrorZ in the success state.
+ * Creates a new CResult_NodeAnnouncementDecodeErrorZ in the success state.
  */
-struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_ok(void);
+struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_ok(struct LDKNodeAnnouncement o);
 
 /**
- * Creates a new CResult_NoneErrorZ in the error state.
+ * Creates a new CResult_NodeAnnouncementDecodeErrorZ in the error state.
  */
-struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_err(enum LDKIOError e);
+struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Frees any resources used by the CResult_NoneErrorZ.
+ * Frees any resources used by the CResult_NodeAnnouncementDecodeErrorZ.
  */
-void CResult_NoneErrorZ_free(struct LDKCResult_NoneErrorZ _res);
+void CResult_NodeAnnouncementDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementDecodeErrorZ _res);
 
 /**
- * Frees the buffer pointed to by `data` if `datalen` is non-0.
+ * Creates a new CResult_NodeAnnouncementDecodeErrorZ which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-void CVec_C2Tuple_BlockHashChannelMonitorZZ_free(struct LDKCVec_C2Tuple_BlockHashChannelMonitorZZ _res);
+struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ in the success state.
+ * Creates a new CResult_QueryShortChannelIdsDecodeErrorZ in the success state.
  */
-struct LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_ok(struct LDKCVec_C2Tuple_BlockHashChannelMonitorZZ o);
+struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_ok(struct LDKQueryShortChannelIds o);
 
 /**
- * Creates a new CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ in the error state.
+ * Creates a new CResult_QueryShortChannelIdsDecodeErrorZ in the error state.
  */
-struct LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_err(enum LDKIOError e);
+struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Frees any resources used by the CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ.
+ * Frees any resources used by the CResult_QueryShortChannelIdsDecodeErrorZ.
  */
-void CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_free(struct LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ _res);
+void CResult_QueryShortChannelIdsDecodeErrorZ_free(struct LDKCResult_QueryShortChannelIdsDecodeErrorZ _res);
 
 /**
- * Creates a new CResult_NoneAPIErrorZ in the success state.
+ * Creates a new CResult_QueryShortChannelIdsDecodeErrorZ which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_ok(void);
+struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_clone(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_NoneAPIErrorZ in the error state.
+ * Creates a new CResult_ReplyShortChannelIdsEndDecodeErrorZ in the success state.
  */
-struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_err(struct LDKAPIError e);
+struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(struct LDKReplyShortChannelIdsEnd o);
 
 /**
- * Frees any resources used by the CResult_NoneAPIErrorZ.
+ * Creates a new CResult_ReplyShortChannelIdsEndDecodeErrorZ in the error state.
  */
-void CResult_NoneAPIErrorZ_free(struct LDKCResult_NoneAPIErrorZ _res);
+struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Creates a new CResult_NoneAPIErrorZ which has the same data as `orig`
- * but with all dynamically-allocated buffers duplicated in new buffers.
+ * Frees any resources used by the CResult_ReplyShortChannelIdsEndDecodeErrorZ.
  */
-struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_clone(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR orig);
+void CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ _res);
 
 /**
- * Frees the buffer pointed to by `data` if `datalen` is non-0.
+ * Creates a new CResult_ReplyShortChannelIdsEndDecodeErrorZ which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-void CVec_CResult_NoneAPIErrorZZ_free(struct LDKCVec_CResult_NoneAPIErrorZZ _res);
+struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Frees the buffer pointed to by `data` if `datalen` is non-0.
+ * Creates a new CResult_QueryChannelRangeDecodeErrorZ in the success state.
  */
-void CVec_APIErrorZ_free(struct LDKCVec_APIErrorZ _res);
+struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_ok(struct LDKQueryChannelRange o);
 
 /**
- * Creates a new CResult_NonePaymentSendFailureZ in the success state.
+ * Creates a new CResult_QueryChannelRangeDecodeErrorZ in the error state.
  */
-struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_ok(void);
+struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Creates a new CResult_NonePaymentSendFailureZ in the error state.
+ * Frees any resources used by the CResult_QueryChannelRangeDecodeErrorZ.
  */
-struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
+void CResult_QueryChannelRangeDecodeErrorZ_free(struct LDKCResult_QueryChannelRangeDecodeErrorZ _res);
 
 /**
- * Frees any resources used by the CResult_NonePaymentSendFailureZ.
+ * Creates a new CResult_QueryChannelRangeDecodeErrorZ which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-void CResult_NonePaymentSendFailureZ_free(struct LDKCResult_NonePaymentSendFailureZ _res);
+struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_clone(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_NonePaymentSendFailureZ which has the same data as `orig`
- * but with all dynamically-allocated buffers duplicated in new buffers.
+ * Creates a new CResult_ReplyChannelRangeDecodeErrorZ in the success state.
  */
-struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_clone(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR orig);
+struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_ok(struct LDKReplyChannelRange o);
 
 /**
- * Creates a new C2Tuple_PaymentHashPaymentSecretZ from the contained elements.
+ * Creates a new CResult_ReplyChannelRangeDecodeErrorZ in the error state.
  */
-struct LDKC2Tuple_PaymentHashPaymentSecretZ C2Tuple_PaymentHashPaymentSecretZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
+struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Frees any resources used by the C2Tuple_PaymentHashPaymentSecretZ.
+ * Frees any resources used by the CResult_ReplyChannelRangeDecodeErrorZ.
  */
-void C2Tuple_PaymentHashPaymentSecretZ_free(struct LDKC2Tuple_PaymentHashPaymentSecretZ _res);
+void CResult_ReplyChannelRangeDecodeErrorZ_free(struct LDKCResult_ReplyChannelRangeDecodeErrorZ _res);
 
 /**
- * Creates a new CResult_PaymentSecretAPIErrorZ in the success state.
+ * Creates a new CResult_ReplyChannelRangeDecodeErrorZ which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_ok(struct LDKThirtyTwoBytes o);
+struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_clone(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Creates a new CResult_PaymentSecretAPIErrorZ in the error state.
+ * Creates a new CResult_GossipTimestampFilterDecodeErrorZ in the success state.
  */
-struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_err(struct LDKAPIError e);
+struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_ok(struct LDKGossipTimestampFilter o);
 
 /**
- * Frees any resources used by the CResult_PaymentSecretAPIErrorZ.
+ * Creates a new CResult_GossipTimestampFilterDecodeErrorZ in the error state.
  */
-void CResult_PaymentSecretAPIErrorZ_free(struct LDKCResult_PaymentSecretAPIErrorZ _res);
+struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_err(struct LDKDecodeError e);
 
 /**
- * Frees the buffer pointed to by `data` if `datalen` is non-0.
+ * Frees any resources used by the CResult_GossipTimestampFilterDecodeErrorZ.
  */
-void CVec_ChannelMonitorZ_free(struct LDKCVec_ChannelMonitorZ _res);
+void CResult_GossipTimestampFilterDecodeErrorZ_free(struct LDKCResult_GossipTimestampFilterDecodeErrorZ _res);
 
 /**
- * Creates a new C2Tuple_BlockHashChannelManagerZ from the contained elements.
+ * Creates a new CResult_GossipTimestampFilterDecodeErrorZ which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-struct LDKC2Tuple_BlockHashChannelManagerZ C2Tuple_BlockHashChannelManagerZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelManager b);
+struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_clone(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR orig);
 
 /**
- * Frees any resources used by the C2Tuple_BlockHashChannelManagerZ.
+ * Creates a new CResult_InvoiceSignOrCreationErrorZ in the success state.
  */
-void C2Tuple_BlockHashChannelManagerZ_free(struct LDKC2Tuple_BlockHashChannelManagerZ _res);
+struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_ok(struct LDKInvoice o);
 
 /**
- * Creates a new CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ in the success state.
+ * Creates a new CResult_InvoiceSignOrCreationErrorZ in the error state.
  */
-struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelManagerZ o);
+struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_err(struct LDKSignOrCreationError e);
 
 /**
- * Creates a new CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ in the error state.
+ * Frees any resources used by the CResult_InvoiceSignOrCreationErrorZ.
  */
-struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(struct LDKDecodeError e);
+void CResult_InvoiceSignOrCreationErrorZ_free(struct LDKCResult_InvoiceSignOrCreationErrorZ _res);
 
 /**
- * Frees any resources used by the CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ.
+ * Creates a new CResult_InvoiceSignOrCreationErrorZ which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
  */
-void CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ _res);
+struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_clone(const struct LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR orig);
 
 /**
  * Frees any resources used by the Event
@@ -17620,6 +17750,43 @@ MUST_USE_RES struct LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ File
  */
 struct LDKPersist FilesystemPersister_as_Persist(const struct LDKFilesystemPersister *NONNULL_PTR this_arg);
 
+/**
+ * Frees any resources used by the BackgroundProcessor, if is_owned is set and inner is non-NULL.
+ */
+void BackgroundProcessor_free(struct LDKBackgroundProcessor this_obj);
+
+/**
+ * Calls the free function if one is set
+ */
+void ChannelManagerPersister_free(struct LDKChannelManagerPersister this_ptr);
+
+/**
+ * Start a background thread that takes care of responsibilities enumerated in the top-level
+ * documentation.
+ *
+ * If `persist_manager` returns an error, then this thread will return said error (and
+ * `start()` will need to be called again to restart the `BackgroundProcessor`). Users should
+ * wait on [`thread_handle`]'s `join()` method to be able to tell if and when an error is
+ * returned, or implement `persist_manager` such that an error is never returned to the
+ * `BackgroundProcessor`
+ *
+ * `persist_manager` is responsible for writing out the [`ChannelManager`] to disk, and/or
+ * uploading to one or more backup services. See [`ChannelManager::write`] for writing out a
+ * [`ChannelManager`]. See [`FilesystemPersister::persist_manager`] for Rust-Lightning's
+ * provided implementation.
+ *
+ * [`thread_handle`]: BackgroundProcessor::thread_handle
+ * [`ChannelManager`]: lightning::ln::channelmanager::ChannelManager
+ * [`ChannelManager::write`]: lightning::ln::channelmanager::ChannelManager#impl-Writeable
+ * [`FilesystemPersister::persist_manager`]: lightning_persister::FilesystemPersister::persist_manager
+ */
+MUST_USE_RES struct LDKBackgroundProcessor BackgroundProcessor_start(struct LDKChannelManagerPersister persister, struct LDKEventHandler event_handler, const struct LDKChainMonitor *NONNULL_PTR chain_monitor, const struct LDKChannelManager *NONNULL_PTR channel_manager, const struct LDKPeerManager *NONNULL_PTR peer_manager, struct LDKLogger logger);
+
+/**
+ * Stop `BackgroundProcessor`'s thread.
+ */
+MUST_USE_RES struct LDKCResult_NoneErrorZ BackgroundProcessor_stop(struct LDKBackgroundProcessor this_arg);
+
 /**
  * **Call this function on startup to ensure that all assumptions about the platform are valid.**
  *
index 329299004db819c4db8160aacdbea2d5adc0b274..0cd1dc46eac215ad99627517ac615028a8286ea7 100644 (file)
@@ -1,95 +1,5 @@
 #include <string.h>
 namespace LDK {
-class ChannelHandshakeConfig {
-private:
-       LDKChannelHandshakeConfig self;
-public:
-       ChannelHandshakeConfig(const ChannelHandshakeConfig&) = delete;
-       ChannelHandshakeConfig(ChannelHandshakeConfig&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelHandshakeConfig)); }
-       ChannelHandshakeConfig(LDKChannelHandshakeConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelHandshakeConfig)); }
-       operator LDKChannelHandshakeConfig() && { LDKChannelHandshakeConfig res = self; memset(&self, 0, sizeof(LDKChannelHandshakeConfig)); return res; }
-       ~ChannelHandshakeConfig() { ChannelHandshakeConfig_free(self); }
-       ChannelHandshakeConfig& operator=(ChannelHandshakeConfig&& o) { ChannelHandshakeConfig_free(self); self = o.self; memset(&o, 0, sizeof(ChannelHandshakeConfig)); return *this; }
-       LDKChannelHandshakeConfig* operator &() { return &self; }
-       LDKChannelHandshakeConfig* operator ->() { return &self; }
-       const LDKChannelHandshakeConfig* operator &() const { return &self; }
-       const LDKChannelHandshakeConfig* operator ->() const { return &self; }
-};
-class ChannelHandshakeLimits {
-private:
-       LDKChannelHandshakeLimits self;
-public:
-       ChannelHandshakeLimits(const ChannelHandshakeLimits&) = delete;
-       ChannelHandshakeLimits(ChannelHandshakeLimits&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelHandshakeLimits)); }
-       ChannelHandshakeLimits(LDKChannelHandshakeLimits&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelHandshakeLimits)); }
-       operator LDKChannelHandshakeLimits() && { LDKChannelHandshakeLimits res = self; memset(&self, 0, sizeof(LDKChannelHandshakeLimits)); return res; }
-       ~ChannelHandshakeLimits() { ChannelHandshakeLimits_free(self); }
-       ChannelHandshakeLimits& operator=(ChannelHandshakeLimits&& o) { ChannelHandshakeLimits_free(self); self = o.self; memset(&o, 0, sizeof(ChannelHandshakeLimits)); return *this; }
-       LDKChannelHandshakeLimits* operator &() { return &self; }
-       LDKChannelHandshakeLimits* operator ->() { return &self; }
-       const LDKChannelHandshakeLimits* operator &() const { return &self; }
-       const LDKChannelHandshakeLimits* operator ->() const { return &self; }
-};
-class ChannelConfig {
-private:
-       LDKChannelConfig self;
-public:
-       ChannelConfig(const ChannelConfig&) = delete;
-       ChannelConfig(ChannelConfig&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelConfig)); }
-       ChannelConfig(LDKChannelConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelConfig)); }
-       operator LDKChannelConfig() && { LDKChannelConfig res = self; memset(&self, 0, sizeof(LDKChannelConfig)); return res; }
-       ~ChannelConfig() { ChannelConfig_free(self); }
-       ChannelConfig& operator=(ChannelConfig&& o) { ChannelConfig_free(self); self = o.self; memset(&o, 0, sizeof(ChannelConfig)); return *this; }
-       LDKChannelConfig* operator &() { return &self; }
-       LDKChannelConfig* operator ->() { return &self; }
-       const LDKChannelConfig* operator &() const { return &self; }
-       const LDKChannelConfig* operator ->() const { return &self; }
-};
-class UserConfig {
-private:
-       LDKUserConfig self;
-public:
-       UserConfig(const UserConfig&) = delete;
-       UserConfig(UserConfig&& o) : self(o.self) { memset(&o, 0, sizeof(UserConfig)); }
-       UserConfig(LDKUserConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUserConfig)); }
-       operator LDKUserConfig() && { LDKUserConfig res = self; memset(&self, 0, sizeof(LDKUserConfig)); return res; }
-       ~UserConfig() { UserConfig_free(self); }
-       UserConfig& operator=(UserConfig&& o) { UserConfig_free(self); self = o.self; memset(&o, 0, sizeof(UserConfig)); return *this; }
-       LDKUserConfig* operator &() { return &self; }
-       LDKUserConfig* operator ->() { return &self; }
-       const LDKUserConfig* operator &() const { return &self; }
-       const LDKUserConfig* operator ->() const { return &self; }
-};
-class APIError {
-private:
-       LDKAPIError self;
-public:
-       APIError(const APIError&) = delete;
-       APIError(APIError&& o) : self(o.self) { memset(&o, 0, sizeof(APIError)); }
-       APIError(LDKAPIError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAPIError)); }
-       operator LDKAPIError() && { LDKAPIError res = self; memset(&self, 0, sizeof(LDKAPIError)); return res; }
-       ~APIError() { APIError_free(self); }
-       APIError& operator=(APIError&& o) { APIError_free(self); self = o.self; memset(&o, 0, sizeof(APIError)); return *this; }
-       LDKAPIError* operator &() { return &self; }
-       LDKAPIError* operator ->() { return &self; }
-       const LDKAPIError* operator &() const { return &self; }
-       const LDKAPIError* operator ->() const { return &self; }
-};
-class OutPoint {
-private:
-       LDKOutPoint self;
-public:
-       OutPoint(const OutPoint&) = delete;
-       OutPoint(OutPoint&& o) : self(o.self) { memset(&o, 0, sizeof(OutPoint)); }
-       OutPoint(LDKOutPoint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOutPoint)); }
-       operator LDKOutPoint() && { LDKOutPoint res = self; memset(&self, 0, sizeof(LDKOutPoint)); return res; }
-       ~OutPoint() { OutPoint_free(self); }
-       OutPoint& operator=(OutPoint&& o) { OutPoint_free(self); self = o.self; memset(&o, 0, sizeof(OutPoint)); return *this; }
-       LDKOutPoint* operator &() { return &self; }
-       LDKOutPoint* operator ->() { return &self; }
-       const LDKOutPoint* operator &() const { return &self; }
-       const LDKOutPoint* operator ->() const { return &self; }
-};
 class TxCreationKeys {
 private:
        LDKTxCreationKeys self;
@@ -240,733 +150,1138 @@ public:
        const LDKTrustedCommitmentTransaction* operator &() const { return &self; }
        const LDKTrustedCommitmentTransaction* operator ->() const { return &self; }
 };
-class Invoice {
+class BackgroundProcessor {
 private:
-       LDKInvoice self;
+       LDKBackgroundProcessor self;
 public:
-       Invoice(const Invoice&) = delete;
-       Invoice(Invoice&& o) : self(o.self) { memset(&o, 0, sizeof(Invoice)); }
-       Invoice(LDKInvoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoice)); }
-       operator LDKInvoice() && { LDKInvoice res = self; memset(&self, 0, sizeof(LDKInvoice)); return res; }
-       ~Invoice() { Invoice_free(self); }
-       Invoice& operator=(Invoice&& o) { Invoice_free(self); self = o.self; memset(&o, 0, sizeof(Invoice)); return *this; }
-       LDKInvoice* operator &() { return &self; }
-       LDKInvoice* operator ->() { return &self; }
-       const LDKInvoice* operator &() const { return &self; }
-       const LDKInvoice* operator ->() const { return &self; }
+       BackgroundProcessor(const BackgroundProcessor&) = delete;
+       BackgroundProcessor(BackgroundProcessor&& o) : self(o.self) { memset(&o, 0, sizeof(BackgroundProcessor)); }
+       BackgroundProcessor(LDKBackgroundProcessor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBackgroundProcessor)); }
+       operator LDKBackgroundProcessor() && { LDKBackgroundProcessor res = self; memset(&self, 0, sizeof(LDKBackgroundProcessor)); return res; }
+       ~BackgroundProcessor() { BackgroundProcessor_free(self); }
+       BackgroundProcessor& operator=(BackgroundProcessor&& o) { BackgroundProcessor_free(self); self = o.self; memset(&o, 0, sizeof(BackgroundProcessor)); return *this; }
+       LDKBackgroundProcessor* operator &() { return &self; }
+       LDKBackgroundProcessor* operator ->() { return &self; }
+       const LDKBackgroundProcessor* operator &() const { return &self; }
+       const LDKBackgroundProcessor* operator ->() const { return &self; }
 };
-class SignedRawInvoice {
+class ChannelManagerPersister {
 private:
-       LDKSignedRawInvoice self;
+       LDKChannelManagerPersister self;
 public:
-       SignedRawInvoice(const SignedRawInvoice&) = delete;
-       SignedRawInvoice(SignedRawInvoice&& o) : self(o.self) { memset(&o, 0, sizeof(SignedRawInvoice)); }
-       SignedRawInvoice(LDKSignedRawInvoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignedRawInvoice)); }
-       operator LDKSignedRawInvoice() && { LDKSignedRawInvoice res = self; memset(&self, 0, sizeof(LDKSignedRawInvoice)); return res; }
-       ~SignedRawInvoice() { SignedRawInvoice_free(self); }
-       SignedRawInvoice& operator=(SignedRawInvoice&& o) { SignedRawInvoice_free(self); self = o.self; memset(&o, 0, sizeof(SignedRawInvoice)); return *this; }
-       LDKSignedRawInvoice* operator &() { return &self; }
-       LDKSignedRawInvoice* operator ->() { return &self; }
-       const LDKSignedRawInvoice* operator &() const { return &self; }
-       const LDKSignedRawInvoice* operator ->() const { return &self; }
+       ChannelManagerPersister(const ChannelManagerPersister&) = delete;
+       ChannelManagerPersister(ChannelManagerPersister&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelManagerPersister)); }
+       ChannelManagerPersister(LDKChannelManagerPersister&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelManagerPersister)); }
+       operator LDKChannelManagerPersister() && { LDKChannelManagerPersister res = self; memset(&self, 0, sizeof(LDKChannelManagerPersister)); return res; }
+       ~ChannelManagerPersister() { ChannelManagerPersister_free(self); }
+       ChannelManagerPersister& operator=(ChannelManagerPersister&& o) { ChannelManagerPersister_free(self); self = o.self; memset(&o, 0, sizeof(ChannelManagerPersister)); return *this; }
+       LDKChannelManagerPersister* operator &() { return &self; }
+       LDKChannelManagerPersister* operator ->() { return &self; }
+       const LDKChannelManagerPersister* operator &() const { return &self; }
+       const LDKChannelManagerPersister* operator ->() const { return &self; }
 };
-class RawInvoice {
+class RouteHop {
 private:
-       LDKRawInvoice self;
+       LDKRouteHop self;
 public:
-       RawInvoice(const RawInvoice&) = delete;
-       RawInvoice(RawInvoice&& o) : self(o.self) { memset(&o, 0, sizeof(RawInvoice)); }
-       RawInvoice(LDKRawInvoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRawInvoice)); }
-       operator LDKRawInvoice() && { LDKRawInvoice res = self; memset(&self, 0, sizeof(LDKRawInvoice)); return res; }
-       ~RawInvoice() { RawInvoice_free(self); }
-       RawInvoice& operator=(RawInvoice&& o) { RawInvoice_free(self); self = o.self; memset(&o, 0, sizeof(RawInvoice)); return *this; }
-       LDKRawInvoice* operator &() { return &self; }
-       LDKRawInvoice* operator ->() { return &self; }
-       const LDKRawInvoice* operator &() const { return &self; }
-       const LDKRawInvoice* operator ->() const { return &self; }
+       RouteHop(const RouteHop&) = delete;
+       RouteHop(RouteHop&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHop)); }
+       RouteHop(LDKRouteHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHop)); }
+       operator LDKRouteHop() && { LDKRouteHop res = self; memset(&self, 0, sizeof(LDKRouteHop)); return res; }
+       ~RouteHop() { RouteHop_free(self); }
+       RouteHop& operator=(RouteHop&& o) { RouteHop_free(self); self = o.self; memset(&o, 0, sizeof(RouteHop)); return *this; }
+       LDKRouteHop* operator &() { return &self; }
+       LDKRouteHop* operator ->() { return &self; }
+       const LDKRouteHop* operator &() const { return &self; }
+       const LDKRouteHop* operator ->() const { return &self; }
 };
-class RawDataPart {
+class Route {
 private:
-       LDKRawDataPart self;
+       LDKRoute self;
 public:
-       RawDataPart(const RawDataPart&) = delete;
-       RawDataPart(RawDataPart&& o) : self(o.self) { memset(&o, 0, sizeof(RawDataPart)); }
-       RawDataPart(LDKRawDataPart&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRawDataPart)); }
-       operator LDKRawDataPart() && { LDKRawDataPart res = self; memset(&self, 0, sizeof(LDKRawDataPart)); return res; }
-       ~RawDataPart() { RawDataPart_free(self); }
-       RawDataPart& operator=(RawDataPart&& o) { RawDataPart_free(self); self = o.self; memset(&o, 0, sizeof(RawDataPart)); return *this; }
-       LDKRawDataPart* operator &() { return &self; }
-       LDKRawDataPart* operator ->() { return &self; }
-       const LDKRawDataPart* operator &() const { return &self; }
-       const LDKRawDataPart* operator ->() const { return &self; }
+       Route(const Route&) = delete;
+       Route(Route&& o) : self(o.self) { memset(&o, 0, sizeof(Route)); }
+       Route(LDKRoute&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoute)); }
+       operator LDKRoute() && { LDKRoute res = self; memset(&self, 0, sizeof(LDKRoute)); return res; }
+       ~Route() { Route_free(self); }
+       Route& operator=(Route&& o) { Route_free(self); self = o.self; memset(&o, 0, sizeof(Route)); return *this; }
+       LDKRoute* operator &() { return &self; }
+       LDKRoute* operator ->() { return &self; }
+       const LDKRoute* operator &() const { return &self; }
+       const LDKRoute* operator ->() const { return &self; }
 };
-class PositiveTimestamp {
+class RouteHintHop {
 private:
-       LDKPositiveTimestamp self;
+       LDKRouteHintHop self;
 public:
-       PositiveTimestamp(const PositiveTimestamp&) = delete;
-       PositiveTimestamp(PositiveTimestamp&& o) : self(o.self) { memset(&o, 0, sizeof(PositiveTimestamp)); }
-       PositiveTimestamp(LDKPositiveTimestamp&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPositiveTimestamp)); }
-       operator LDKPositiveTimestamp() && { LDKPositiveTimestamp res = self; memset(&self, 0, sizeof(LDKPositiveTimestamp)); return res; }
-       ~PositiveTimestamp() { PositiveTimestamp_free(self); }
-       PositiveTimestamp& operator=(PositiveTimestamp&& o) { PositiveTimestamp_free(self); self = o.self; memset(&o, 0, sizeof(PositiveTimestamp)); return *this; }
-       LDKPositiveTimestamp* operator &() { return &self; }
-       LDKPositiveTimestamp* operator ->() { return &self; }
-       const LDKPositiveTimestamp* operator &() const { return &self; }
-       const LDKPositiveTimestamp* operator ->() const { return &self; }
+       RouteHintHop(const RouteHintHop&) = delete;
+       RouteHintHop(RouteHintHop&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHintHop)); }
+       RouteHintHop(LDKRouteHintHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHintHop)); }
+       operator LDKRouteHintHop() && { LDKRouteHintHop res = self; memset(&self, 0, sizeof(LDKRouteHintHop)); return res; }
+       ~RouteHintHop() { RouteHintHop_free(self); }
+       RouteHintHop& operator=(RouteHintHop&& o) { RouteHintHop_free(self); self = o.self; memset(&o, 0, sizeof(RouteHintHop)); return *this; }
+       LDKRouteHintHop* operator &() { return &self; }
+       LDKRouteHintHop* operator ->() { return &self; }
+       const LDKRouteHintHop* operator &() const { return &self; }
+       const LDKRouteHintHop* operator ->() const { return &self; }
 };
-class SiPrefix {
+class BroadcasterInterface {
 private:
-       LDKSiPrefix self;
+       LDKBroadcasterInterface self;
 public:
-       SiPrefix(const SiPrefix&) = delete;
-       SiPrefix(SiPrefix&& o) : self(o.self) { memset(&o, 0, sizeof(SiPrefix)); }
-       SiPrefix(LDKSiPrefix&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSiPrefix)); }
-       operator LDKSiPrefix() && { LDKSiPrefix res = self; memset(&self, 0, sizeof(LDKSiPrefix)); return res; }
-       SiPrefix& operator=(SiPrefix&& o) { self = o.self; memset(&o, 0, sizeof(SiPrefix)); return *this; }
-       LDKSiPrefix* operator &() { return &self; }
-       LDKSiPrefix* operator ->() { return &self; }
-       const LDKSiPrefix* operator &() const { return &self; }
-       const LDKSiPrefix* operator ->() const { return &self; }
+       BroadcasterInterface(const BroadcasterInterface&) = delete;
+       BroadcasterInterface(BroadcasterInterface&& o) : self(o.self) { memset(&o, 0, sizeof(BroadcasterInterface)); }
+       BroadcasterInterface(LDKBroadcasterInterface&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBroadcasterInterface)); }
+       operator LDKBroadcasterInterface() && { LDKBroadcasterInterface res = self; memset(&self, 0, sizeof(LDKBroadcasterInterface)); return res; }
+       ~BroadcasterInterface() { BroadcasterInterface_free(self); }
+       BroadcasterInterface& operator=(BroadcasterInterface&& o) { BroadcasterInterface_free(self); self = o.self; memset(&o, 0, sizeof(BroadcasterInterface)); return *this; }
+       LDKBroadcasterInterface* operator &() { return &self; }
+       LDKBroadcasterInterface* operator ->() { return &self; }
+       const LDKBroadcasterInterface* operator &() const { return &self; }
+       const LDKBroadcasterInterface* operator ->() const { return &self; }
 };
-class Currency {
+class ConfirmationTarget {
 private:
-       LDKCurrency self;
+       LDKConfirmationTarget self;
 public:
-       Currency(const Currency&) = delete;
-       Currency(Currency&& o) : self(o.self) { memset(&o, 0, sizeof(Currency)); }
-       Currency(LDKCurrency&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCurrency)); }
-       operator LDKCurrency() && { LDKCurrency res = self; memset(&self, 0, sizeof(LDKCurrency)); return res; }
-       Currency& operator=(Currency&& o) { self = o.self; memset(&o, 0, sizeof(Currency)); return *this; }
-       LDKCurrency* operator &() { return &self; }
-       LDKCurrency* operator ->() { return &self; }
-       const LDKCurrency* operator &() const { return &self; }
-       const LDKCurrency* operator ->() const { return &self; }
+       ConfirmationTarget(const ConfirmationTarget&) = delete;
+       ConfirmationTarget(ConfirmationTarget&& o) : self(o.self) { memset(&o, 0, sizeof(ConfirmationTarget)); }
+       ConfirmationTarget(LDKConfirmationTarget&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKConfirmationTarget)); }
+       operator LDKConfirmationTarget() && { LDKConfirmationTarget res = self; memset(&self, 0, sizeof(LDKConfirmationTarget)); return res; }
+       ConfirmationTarget& operator=(ConfirmationTarget&& o) { self = o.self; memset(&o, 0, sizeof(ConfirmationTarget)); return *this; }
+       LDKConfirmationTarget* operator &() { return &self; }
+       LDKConfirmationTarget* operator ->() { return &self; }
+       const LDKConfirmationTarget* operator &() const { return &self; }
+       const LDKConfirmationTarget* operator ->() const { return &self; }
 };
-class Sha256 {
+class FeeEstimator {
 private:
-       LDKSha256 self;
+       LDKFeeEstimator self;
 public:
-       Sha256(const Sha256&) = delete;
-       Sha256(Sha256&& o) : self(o.self) { memset(&o, 0, sizeof(Sha256)); }
-       Sha256(LDKSha256&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSha256)); }
-       operator LDKSha256() && { LDKSha256 res = self; memset(&self, 0, sizeof(LDKSha256)); return res; }
-       ~Sha256() { Sha256_free(self); }
-       Sha256& operator=(Sha256&& o) { Sha256_free(self); self = o.self; memset(&o, 0, sizeof(Sha256)); return *this; }
-       LDKSha256* operator &() { return &self; }
-       LDKSha256* operator ->() { return &self; }
-       const LDKSha256* operator &() const { return &self; }
-       const LDKSha256* operator ->() const { return &self; }
+       FeeEstimator(const FeeEstimator&) = delete;
+       FeeEstimator(FeeEstimator&& o) : self(o.self) { memset(&o, 0, sizeof(FeeEstimator)); }
+       FeeEstimator(LDKFeeEstimator&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFeeEstimator)); }
+       operator LDKFeeEstimator() && { LDKFeeEstimator res = self; memset(&self, 0, sizeof(LDKFeeEstimator)); return res; }
+       ~FeeEstimator() { FeeEstimator_free(self); }
+       FeeEstimator& operator=(FeeEstimator&& o) { FeeEstimator_free(self); self = o.self; memset(&o, 0, sizeof(FeeEstimator)); return *this; }
+       LDKFeeEstimator* operator &() { return &self; }
+       LDKFeeEstimator* operator ->() { return &self; }
+       const LDKFeeEstimator* operator &() const { return &self; }
+       const LDKFeeEstimator* operator ->() const { return &self; }
 };
-class Description {
-private:
-       LDKDescription self;
-public:
-       Description(const Description&) = delete;
-       Description(Description&& o) : self(o.self) { memset(&o, 0, sizeof(Description)); }
-       Description(LDKDescription&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDescription)); }
-       operator LDKDescription() && { LDKDescription res = self; memset(&self, 0, sizeof(LDKDescription)); return res; }
-       ~Description() { Description_free(self); }
-       Description& operator=(Description&& o) { Description_free(self); self = o.self; memset(&o, 0, sizeof(Description)); return *this; }
-       LDKDescription* operator &() { return &self; }
-       LDKDescription* operator ->() { return &self; }
-       const LDKDescription* operator &() const { return &self; }
-       const LDKDescription* operator ->() const { return &self; }
-};
-class PayeePubKey {
+class AccessError {
 private:
-       LDKPayeePubKey self;
+       LDKAccessError self;
 public:
-       PayeePubKey(const PayeePubKey&) = delete;
-       PayeePubKey(PayeePubKey&& o) : self(o.self) { memset(&o, 0, sizeof(PayeePubKey)); }
-       PayeePubKey(LDKPayeePubKey&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPayeePubKey)); }
-       operator LDKPayeePubKey() && { LDKPayeePubKey res = self; memset(&self, 0, sizeof(LDKPayeePubKey)); return res; }
-       ~PayeePubKey() { PayeePubKey_free(self); }
-       PayeePubKey& operator=(PayeePubKey&& o) { PayeePubKey_free(self); self = o.self; memset(&o, 0, sizeof(PayeePubKey)); return *this; }
-       LDKPayeePubKey* operator &() { return &self; }
-       LDKPayeePubKey* operator ->() { return &self; }
-       const LDKPayeePubKey* operator &() const { return &self; }
-       const LDKPayeePubKey* operator ->() const { return &self; }
+       AccessError(const AccessError&) = delete;
+       AccessError(AccessError&& o) : self(o.self) { memset(&o, 0, sizeof(AccessError)); }
+       AccessError(LDKAccessError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAccessError)); }
+       operator LDKAccessError() && { LDKAccessError res = self; memset(&self, 0, sizeof(LDKAccessError)); return res; }
+       AccessError& operator=(AccessError&& o) { self = o.self; memset(&o, 0, sizeof(AccessError)); return *this; }
+       LDKAccessError* operator &() { return &self; }
+       LDKAccessError* operator ->() { return &self; }
+       const LDKAccessError* operator &() const { return &self; }
+       const LDKAccessError* operator ->() const { return &self; }
 };
-class ExpiryTime {
+class Access {
 private:
-       LDKExpiryTime self;
+       LDKAccess self;
 public:
-       ExpiryTime(const ExpiryTime&) = delete;
-       ExpiryTime(ExpiryTime&& o) : self(o.self) { memset(&o, 0, sizeof(ExpiryTime)); }
-       ExpiryTime(LDKExpiryTime&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKExpiryTime)); }
-       operator LDKExpiryTime() && { LDKExpiryTime res = self; memset(&self, 0, sizeof(LDKExpiryTime)); return res; }
-       ~ExpiryTime() { ExpiryTime_free(self); }
-       ExpiryTime& operator=(ExpiryTime&& o) { ExpiryTime_free(self); self = o.self; memset(&o, 0, sizeof(ExpiryTime)); return *this; }
-       LDKExpiryTime* operator &() { return &self; }
-       LDKExpiryTime* operator ->() { return &self; }
-       const LDKExpiryTime* operator &() const { return &self; }
-       const LDKExpiryTime* operator ->() const { return &self; }
+       Access(const Access&) = delete;
+       Access(Access&& o) : self(o.self) { memset(&o, 0, sizeof(Access)); }
+       Access(LDKAccess&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAccess)); }
+       operator LDKAccess() && { LDKAccess res = self; memset(&self, 0, sizeof(LDKAccess)); return res; }
+       ~Access() { Access_free(self); }
+       Access& operator=(Access&& o) { Access_free(self); self = o.self; memset(&o, 0, sizeof(Access)); return *this; }
+       LDKAccess* operator &() { return &self; }
+       LDKAccess* operator ->() { return &self; }
+       const LDKAccess* operator &() const { return &self; }
+       const LDKAccess* operator ->() const { return &self; }
 };
-class MinFinalCltvExpiry {
+class Listen {
 private:
-       LDKMinFinalCltvExpiry self;
+       LDKListen self;
 public:
-       MinFinalCltvExpiry(const MinFinalCltvExpiry&) = delete;
-       MinFinalCltvExpiry(MinFinalCltvExpiry&& o) : self(o.self) { memset(&o, 0, sizeof(MinFinalCltvExpiry)); }
-       MinFinalCltvExpiry(LDKMinFinalCltvExpiry&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMinFinalCltvExpiry)); }
-       operator LDKMinFinalCltvExpiry() && { LDKMinFinalCltvExpiry res = self; memset(&self, 0, sizeof(LDKMinFinalCltvExpiry)); return res; }
-       ~MinFinalCltvExpiry() { MinFinalCltvExpiry_free(self); }
-       MinFinalCltvExpiry& operator=(MinFinalCltvExpiry&& o) { MinFinalCltvExpiry_free(self); self = o.self; memset(&o, 0, sizeof(MinFinalCltvExpiry)); return *this; }
-       LDKMinFinalCltvExpiry* operator &() { return &self; }
-       LDKMinFinalCltvExpiry* operator ->() { return &self; }
-       const LDKMinFinalCltvExpiry* operator &() const { return &self; }
-       const LDKMinFinalCltvExpiry* operator ->() const { return &self; }
+       Listen(const Listen&) = delete;
+       Listen(Listen&& o) : self(o.self) { memset(&o, 0, sizeof(Listen)); }
+       Listen(LDKListen&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKListen)); }
+       operator LDKListen() && { LDKListen res = self; memset(&self, 0, sizeof(LDKListen)); return res; }
+       ~Listen() { Listen_free(self); }
+       Listen& operator=(Listen&& o) { Listen_free(self); self = o.self; memset(&o, 0, sizeof(Listen)); return *this; }
+       LDKListen* operator &() { return &self; }
+       LDKListen* operator ->() { return &self; }
+       const LDKListen* operator &() const { return &self; }
+       const LDKListen* operator ->() const { return &self; }
 };
-class Fallback {
+class Confirm {
 private:
-       LDKFallback self;
+       LDKConfirm self;
 public:
-       Fallback(const Fallback&) = delete;
-       Fallback(Fallback&& o) : self(o.self) { memset(&o, 0, sizeof(Fallback)); }
-       Fallback(LDKFallback&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFallback)); }
-       operator LDKFallback() && { LDKFallback res = self; memset(&self, 0, sizeof(LDKFallback)); return res; }
-       ~Fallback() { Fallback_free(self); }
-       Fallback& operator=(Fallback&& o) { Fallback_free(self); self = o.self; memset(&o, 0, sizeof(Fallback)); return *this; }
-       LDKFallback* operator &() { return &self; }
-       LDKFallback* operator ->() { return &self; }
-       const LDKFallback* operator &() const { return &self; }
-       const LDKFallback* operator ->() const { return &self; }
+       Confirm(const Confirm&) = delete;
+       Confirm(Confirm&& o) : self(o.self) { memset(&o, 0, sizeof(Confirm)); }
+       Confirm(LDKConfirm&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKConfirm)); }
+       operator LDKConfirm() && { LDKConfirm res = self; memset(&self, 0, sizeof(LDKConfirm)); return res; }
+       ~Confirm() { Confirm_free(self); }
+       Confirm& operator=(Confirm&& o) { Confirm_free(self); self = o.self; memset(&o, 0, sizeof(Confirm)); return *this; }
+       LDKConfirm* operator &() { return &self; }
+       LDKConfirm* operator ->() { return &self; }
+       const LDKConfirm* operator &() const { return &self; }
+       const LDKConfirm* operator ->() const { return &self; }
 };
-class InvoiceSignature {
+class Watch {
 private:
-       LDKInvoiceSignature self;
+       LDKWatch self;
 public:
-       InvoiceSignature(const InvoiceSignature&) = delete;
-       InvoiceSignature(InvoiceSignature&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceSignature)); }
-       InvoiceSignature(LDKInvoiceSignature&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceSignature)); }
-       operator LDKInvoiceSignature() && { LDKInvoiceSignature res = self; memset(&self, 0, sizeof(LDKInvoiceSignature)); return res; }
-       ~InvoiceSignature() { InvoiceSignature_free(self); }
-       InvoiceSignature& operator=(InvoiceSignature&& o) { InvoiceSignature_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceSignature)); return *this; }
-       LDKInvoiceSignature* operator &() { return &self; }
-       LDKInvoiceSignature* operator ->() { return &self; }
-       const LDKInvoiceSignature* operator &() const { return &self; }
-       const LDKInvoiceSignature* operator ->() const { return &self; }
+       Watch(const Watch&) = delete;
+       Watch(Watch&& o) : self(o.self) { memset(&o, 0, sizeof(Watch)); }
+       Watch(LDKWatch&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWatch)); }
+       operator LDKWatch() && { LDKWatch res = self; memset(&self, 0, sizeof(LDKWatch)); return res; }
+       ~Watch() { Watch_free(self); }
+       Watch& operator=(Watch&& o) { Watch_free(self); self = o.self; memset(&o, 0, sizeof(Watch)); return *this; }
+       LDKWatch* operator &() { return &self; }
+       LDKWatch* operator ->() { return &self; }
+       const LDKWatch* operator &() const { return &self; }
+       const LDKWatch* operator ->() const { return &self; }
 };
-class RouteHint {
+class Filter {
 private:
-       LDKRouteHint self;
+       LDKFilter self;
 public:
-       RouteHint(const RouteHint&) = delete;
-       RouteHint(RouteHint&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHint)); }
-       RouteHint(LDKRouteHint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHint)); }
-       operator LDKRouteHint() && { LDKRouteHint res = self; memset(&self, 0, sizeof(LDKRouteHint)); return res; }
-       ~RouteHint() { RouteHint_free(self); }
-       RouteHint& operator=(RouteHint&& o) { RouteHint_free(self); self = o.self; memset(&o, 0, sizeof(RouteHint)); return *this; }
-       LDKRouteHint* operator &() { return &self; }
-       LDKRouteHint* operator ->() { return &self; }
-       const LDKRouteHint* operator &() const { return &self; }
-       const LDKRouteHint* operator ->() const { return &self; }
+       Filter(const Filter&) = delete;
+       Filter(Filter&& o) : self(o.self) { memset(&o, 0, sizeof(Filter)); }
+       Filter(LDKFilter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFilter)); }
+       operator LDKFilter() && { LDKFilter res = self; memset(&self, 0, sizeof(LDKFilter)); return res; }
+       ~Filter() { Filter_free(self); }
+       Filter& operator=(Filter&& o) { Filter_free(self); self = o.self; memset(&o, 0, sizeof(Filter)); return *this; }
+       LDKFilter* operator &() { return &self; }
+       LDKFilter* operator ->() { return &self; }
+       const LDKFilter* operator &() const { return &self; }
+       const LDKFilter* operator ->() const { return &self; }
 };
-class CreationError {
+class WatchedOutput {
 private:
-       LDKCreationError self;
+       LDKWatchedOutput self;
 public:
-       CreationError(const CreationError&) = delete;
-       CreationError(CreationError&& o) : self(o.self) { memset(&o, 0, sizeof(CreationError)); }
-       CreationError(LDKCreationError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCreationError)); }
-       operator LDKCreationError() && { LDKCreationError res = self; memset(&self, 0, sizeof(LDKCreationError)); return res; }
-       CreationError& operator=(CreationError&& o) { self = o.self; memset(&o, 0, sizeof(CreationError)); return *this; }
-       LDKCreationError* operator &() { return &self; }
-       LDKCreationError* operator ->() { return &self; }
-       const LDKCreationError* operator &() const { return &self; }
-       const LDKCreationError* operator ->() const { return &self; }
+       WatchedOutput(const WatchedOutput&) = delete;
+       WatchedOutput(WatchedOutput&& o) : self(o.self) { memset(&o, 0, sizeof(WatchedOutput)); }
+       WatchedOutput(LDKWatchedOutput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWatchedOutput)); }
+       operator LDKWatchedOutput() && { LDKWatchedOutput res = self; memset(&self, 0, sizeof(LDKWatchedOutput)); return res; }
+       ~WatchedOutput() { WatchedOutput_free(self); }
+       WatchedOutput& operator=(WatchedOutput&& o) { WatchedOutput_free(self); self = o.self; memset(&o, 0, sizeof(WatchedOutput)); return *this; }
+       LDKWatchedOutput* operator &() { return &self; }
+       LDKWatchedOutput* operator ->() { return &self; }
+       const LDKWatchedOutput* operator &() const { return &self; }
+       const LDKWatchedOutput* operator ->() const { return &self; }
 };
-class SemanticError {
+class Event {
 private:
-       LDKSemanticError self;
+       LDKEvent self;
 public:
-       SemanticError(const SemanticError&) = delete;
-       SemanticError(SemanticError&& o) : self(o.self) { memset(&o, 0, sizeof(SemanticError)); }
-       SemanticError(LDKSemanticError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSemanticError)); }
-       operator LDKSemanticError() && { LDKSemanticError res = self; memset(&self, 0, sizeof(LDKSemanticError)); return res; }
-       SemanticError& operator=(SemanticError&& o) { self = o.self; memset(&o, 0, sizeof(SemanticError)); return *this; }
-       LDKSemanticError* operator &() { return &self; }
-       LDKSemanticError* operator ->() { return &self; }
-       const LDKSemanticError* operator &() const { return &self; }
-       const LDKSemanticError* operator ->() const { return &self; }
+       Event(const Event&) = delete;
+       Event(Event&& o) : self(o.self) { memset(&o, 0, sizeof(Event)); }
+       Event(LDKEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEvent)); }
+       operator LDKEvent() && { LDKEvent res = self; memset(&self, 0, sizeof(LDKEvent)); return res; }
+       ~Event() { Event_free(self); }
+       Event& operator=(Event&& o) { Event_free(self); self = o.self; memset(&o, 0, sizeof(Event)); return *this; }
+       LDKEvent* operator &() { return &self; }
+       LDKEvent* operator ->() { return &self; }
+       const LDKEvent* operator &() const { return &self; }
+       const LDKEvent* operator ->() const { return &self; }
 };
-class SignOrCreationError {
+class MessageSendEvent {
 private:
-       LDKSignOrCreationError self;
+       LDKMessageSendEvent self;
 public:
-       SignOrCreationError(const SignOrCreationError&) = delete;
-       SignOrCreationError(SignOrCreationError&& o) : self(o.self) { memset(&o, 0, sizeof(SignOrCreationError)); }
-       SignOrCreationError(LDKSignOrCreationError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignOrCreationError)); }
-       operator LDKSignOrCreationError() && { LDKSignOrCreationError res = self; memset(&self, 0, sizeof(LDKSignOrCreationError)); return res; }
-       ~SignOrCreationError() { SignOrCreationError_free(self); }
-       SignOrCreationError& operator=(SignOrCreationError&& o) { SignOrCreationError_free(self); self = o.self; memset(&o, 0, sizeof(SignOrCreationError)); return *this; }
-       LDKSignOrCreationError* operator &() { return &self; }
-       LDKSignOrCreationError* operator ->() { return &self; }
-       const LDKSignOrCreationError* operator &() const { return &self; }
-       const LDKSignOrCreationError* operator ->() const { return &self; }
+       MessageSendEvent(const MessageSendEvent&) = delete;
+       MessageSendEvent(MessageSendEvent&& o) : self(o.self) { memset(&o, 0, sizeof(MessageSendEvent)); }
+       MessageSendEvent(LDKMessageSendEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageSendEvent)); }
+       operator LDKMessageSendEvent() && { LDKMessageSendEvent res = self; memset(&self, 0, sizeof(LDKMessageSendEvent)); return res; }
+       ~MessageSendEvent() { MessageSendEvent_free(self); }
+       MessageSendEvent& operator=(MessageSendEvent&& o) { MessageSendEvent_free(self); self = o.self; memset(&o, 0, sizeof(MessageSendEvent)); return *this; }
+       LDKMessageSendEvent* operator &() { return &self; }
+       LDKMessageSendEvent* operator ->() { return &self; }
+       const LDKMessageSendEvent* operator &() const { return &self; }
+       const LDKMessageSendEvent* operator ->() const { return &self; }
 };
-class ChannelMonitorUpdate {
+class MessageSendEventsProvider {
 private:
-       LDKChannelMonitorUpdate self;
+       LDKMessageSendEventsProvider self;
 public:
-       ChannelMonitorUpdate(const ChannelMonitorUpdate&) = delete;
-       ChannelMonitorUpdate(ChannelMonitorUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitorUpdate)); }
-       ChannelMonitorUpdate(LDKChannelMonitorUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitorUpdate)); }
-       operator LDKChannelMonitorUpdate() && { LDKChannelMonitorUpdate res = self; memset(&self, 0, sizeof(LDKChannelMonitorUpdate)); return res; }
-       ~ChannelMonitorUpdate() { ChannelMonitorUpdate_free(self); }
-       ChannelMonitorUpdate& operator=(ChannelMonitorUpdate&& o) { ChannelMonitorUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMonitorUpdate)); return *this; }
-       LDKChannelMonitorUpdate* operator &() { return &self; }
-       LDKChannelMonitorUpdate* operator ->() { return &self; }
-       const LDKChannelMonitorUpdate* operator &() const { return &self; }
-       const LDKChannelMonitorUpdate* operator ->() const { return &self; }
+       MessageSendEventsProvider(const MessageSendEventsProvider&) = delete;
+       MessageSendEventsProvider(MessageSendEventsProvider&& o) : self(o.self) { memset(&o, 0, sizeof(MessageSendEventsProvider)); }
+       MessageSendEventsProvider(LDKMessageSendEventsProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageSendEventsProvider)); }
+       operator LDKMessageSendEventsProvider() && { LDKMessageSendEventsProvider res = self; memset(&self, 0, sizeof(LDKMessageSendEventsProvider)); return res; }
+       ~MessageSendEventsProvider() { MessageSendEventsProvider_free(self); }
+       MessageSendEventsProvider& operator=(MessageSendEventsProvider&& o) { MessageSendEventsProvider_free(self); self = o.self; memset(&o, 0, sizeof(MessageSendEventsProvider)); return *this; }
+       LDKMessageSendEventsProvider* operator &() { return &self; }
+       LDKMessageSendEventsProvider* operator ->() { return &self; }
+       const LDKMessageSendEventsProvider* operator &() const { return &self; }
+       const LDKMessageSendEventsProvider* operator ->() const { return &self; }
 };
-class ChannelMonitorUpdateErr {
+class EventsProvider {
 private:
-       LDKChannelMonitorUpdateErr self;
+       LDKEventsProvider self;
 public:
-       ChannelMonitorUpdateErr(const ChannelMonitorUpdateErr&) = delete;
-       ChannelMonitorUpdateErr(ChannelMonitorUpdateErr&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitorUpdateErr)); }
-       ChannelMonitorUpdateErr(LDKChannelMonitorUpdateErr&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitorUpdateErr)); }
-       operator LDKChannelMonitorUpdateErr() && { LDKChannelMonitorUpdateErr res = self; memset(&self, 0, sizeof(LDKChannelMonitorUpdateErr)); return res; }
-       ChannelMonitorUpdateErr& operator=(ChannelMonitorUpdateErr&& o) { self = o.self; memset(&o, 0, sizeof(ChannelMonitorUpdateErr)); return *this; }
-       LDKChannelMonitorUpdateErr* operator &() { return &self; }
-       LDKChannelMonitorUpdateErr* operator ->() { return &self; }
-       const LDKChannelMonitorUpdateErr* operator &() const { return &self; }
-       const LDKChannelMonitorUpdateErr* operator ->() const { return &self; }
+       EventsProvider(const EventsProvider&) = delete;
+       EventsProvider(EventsProvider&& o) : self(o.self) { memset(&o, 0, sizeof(EventsProvider)); }
+       EventsProvider(LDKEventsProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEventsProvider)); }
+       operator LDKEventsProvider() && { LDKEventsProvider res = self; memset(&self, 0, sizeof(LDKEventsProvider)); return res; }
+       ~EventsProvider() { EventsProvider_free(self); }
+       EventsProvider& operator=(EventsProvider&& o) { EventsProvider_free(self); self = o.self; memset(&o, 0, sizeof(EventsProvider)); return *this; }
+       LDKEventsProvider* operator &() { return &self; }
+       LDKEventsProvider* operator ->() { return &self; }
+       const LDKEventsProvider* operator &() const { return &self; }
+       const LDKEventsProvider* operator ->() const { return &self; }
+};
+class EventHandler {
+private:
+       LDKEventHandler self;
+public:
+       EventHandler(const EventHandler&) = delete;
+       EventHandler(EventHandler&& o) : self(o.self) { memset(&o, 0, sizeof(EventHandler)); }
+       EventHandler(LDKEventHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEventHandler)); }
+       operator LDKEventHandler() && { LDKEventHandler res = self; memset(&self, 0, sizeof(LDKEventHandler)); return res; }
+       ~EventHandler() { EventHandler_free(self); }
+       EventHandler& operator=(EventHandler&& o) { EventHandler_free(self); self = o.self; memset(&o, 0, sizeof(EventHandler)); return *this; }
+       LDKEventHandler* operator &() { return &self; }
+       LDKEventHandler* operator ->() { return &self; }
+       const LDKEventHandler* operator &() const { return &self; }
+       const LDKEventHandler* operator ->() const { return &self; }
+};
+class InitFeatures {
+private:
+       LDKInitFeatures self;
+public:
+       InitFeatures(const InitFeatures&) = delete;
+       InitFeatures(InitFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(InitFeatures)); }
+       InitFeatures(LDKInitFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInitFeatures)); }
+       operator LDKInitFeatures() && { LDKInitFeatures res = self; memset(&self, 0, sizeof(LDKInitFeatures)); return res; }
+       ~InitFeatures() { InitFeatures_free(self); }
+       InitFeatures& operator=(InitFeatures&& o) { InitFeatures_free(self); self = o.self; memset(&o, 0, sizeof(InitFeatures)); return *this; }
+       LDKInitFeatures* operator &() { return &self; }
+       LDKInitFeatures* operator ->() { return &self; }
+       const LDKInitFeatures* operator &() const { return &self; }
+       const LDKInitFeatures* operator ->() const { return &self; }
+};
+class NodeFeatures {
+private:
+       LDKNodeFeatures self;
+public:
+       NodeFeatures(const NodeFeatures&) = delete;
+       NodeFeatures(NodeFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(NodeFeatures)); }
+       NodeFeatures(LDKNodeFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeFeatures)); }
+       operator LDKNodeFeatures() && { LDKNodeFeatures res = self; memset(&self, 0, sizeof(LDKNodeFeatures)); return res; }
+       ~NodeFeatures() { NodeFeatures_free(self); }
+       NodeFeatures& operator=(NodeFeatures&& o) { NodeFeatures_free(self); self = o.self; memset(&o, 0, sizeof(NodeFeatures)); return *this; }
+       LDKNodeFeatures* operator &() { return &self; }
+       LDKNodeFeatures* operator ->() { return &self; }
+       const LDKNodeFeatures* operator &() const { return &self; }
+       const LDKNodeFeatures* operator ->() const { return &self; }
+};
+class ChannelFeatures {
+private:
+       LDKChannelFeatures self;
+public:
+       ChannelFeatures(const ChannelFeatures&) = delete;
+       ChannelFeatures(ChannelFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelFeatures)); }
+       ChannelFeatures(LDKChannelFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelFeatures)); }
+       operator LDKChannelFeatures() && { LDKChannelFeatures res = self; memset(&self, 0, sizeof(LDKChannelFeatures)); return res; }
+       ~ChannelFeatures() { ChannelFeatures_free(self); }
+       ChannelFeatures& operator=(ChannelFeatures&& o) { ChannelFeatures_free(self); self = o.self; memset(&o, 0, sizeof(ChannelFeatures)); return *this; }
+       LDKChannelFeatures* operator &() { return &self; }
+       LDKChannelFeatures* operator ->() { return &self; }
+       const LDKChannelFeatures* operator &() const { return &self; }
+       const LDKChannelFeatures* operator ->() const { return &self; }
+};
+class InvoiceFeatures {
+private:
+       LDKInvoiceFeatures self;
+public:
+       InvoiceFeatures(const InvoiceFeatures&) = delete;
+       InvoiceFeatures(InvoiceFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceFeatures)); }
+       InvoiceFeatures(LDKInvoiceFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceFeatures)); }
+       operator LDKInvoiceFeatures() && { LDKInvoiceFeatures res = self; memset(&self, 0, sizeof(LDKInvoiceFeatures)); return res; }
+       ~InvoiceFeatures() { InvoiceFeatures_free(self); }
+       InvoiceFeatures& operator=(InvoiceFeatures&& o) { InvoiceFeatures_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceFeatures)); return *this; }
+       LDKInvoiceFeatures* operator &() { return &self; }
+       LDKInvoiceFeatures* operator ->() { return &self; }
+       const LDKInvoiceFeatures* operator &() const { return &self; }
+       const LDKInvoiceFeatures* operator ->() const { return &self; }
+};
+class DelayedPaymentOutputDescriptor {
+private:
+       LDKDelayedPaymentOutputDescriptor self;
+public:
+       DelayedPaymentOutputDescriptor(const DelayedPaymentOutputDescriptor&) = delete;
+       DelayedPaymentOutputDescriptor(DelayedPaymentOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(DelayedPaymentOutputDescriptor)); }
+       DelayedPaymentOutputDescriptor(LDKDelayedPaymentOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDelayedPaymentOutputDescriptor)); }
+       operator LDKDelayedPaymentOutputDescriptor() && { LDKDelayedPaymentOutputDescriptor res = self; memset(&self, 0, sizeof(LDKDelayedPaymentOutputDescriptor)); return res; }
+       ~DelayedPaymentOutputDescriptor() { DelayedPaymentOutputDescriptor_free(self); }
+       DelayedPaymentOutputDescriptor& operator=(DelayedPaymentOutputDescriptor&& o) { DelayedPaymentOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(DelayedPaymentOutputDescriptor)); return *this; }
+       LDKDelayedPaymentOutputDescriptor* operator &() { return &self; }
+       LDKDelayedPaymentOutputDescriptor* operator ->() { return &self; }
+       const LDKDelayedPaymentOutputDescriptor* operator &() const { return &self; }
+       const LDKDelayedPaymentOutputDescriptor* operator ->() const { return &self; }
+};
+class StaticPaymentOutputDescriptor {
+private:
+       LDKStaticPaymentOutputDescriptor self;
+public:
+       StaticPaymentOutputDescriptor(const StaticPaymentOutputDescriptor&) = delete;
+       StaticPaymentOutputDescriptor(StaticPaymentOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(StaticPaymentOutputDescriptor)); }
+       StaticPaymentOutputDescriptor(LDKStaticPaymentOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKStaticPaymentOutputDescriptor)); }
+       operator LDKStaticPaymentOutputDescriptor() && { LDKStaticPaymentOutputDescriptor res = self; memset(&self, 0, sizeof(LDKStaticPaymentOutputDescriptor)); return res; }
+       ~StaticPaymentOutputDescriptor() { StaticPaymentOutputDescriptor_free(self); }
+       StaticPaymentOutputDescriptor& operator=(StaticPaymentOutputDescriptor&& o) { StaticPaymentOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(StaticPaymentOutputDescriptor)); return *this; }
+       LDKStaticPaymentOutputDescriptor* operator &() { return &self; }
+       LDKStaticPaymentOutputDescriptor* operator ->() { return &self; }
+       const LDKStaticPaymentOutputDescriptor* operator &() const { return &self; }
+       const LDKStaticPaymentOutputDescriptor* operator ->() const { return &self; }
+};
+class SpendableOutputDescriptor {
+private:
+       LDKSpendableOutputDescriptor self;
+public:
+       SpendableOutputDescriptor(const SpendableOutputDescriptor&) = delete;
+       SpendableOutputDescriptor(SpendableOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(SpendableOutputDescriptor)); }
+       SpendableOutputDescriptor(LDKSpendableOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSpendableOutputDescriptor)); }
+       operator LDKSpendableOutputDescriptor() && { LDKSpendableOutputDescriptor res = self; memset(&self, 0, sizeof(LDKSpendableOutputDescriptor)); return res; }
+       ~SpendableOutputDescriptor() { SpendableOutputDescriptor_free(self); }
+       SpendableOutputDescriptor& operator=(SpendableOutputDescriptor&& o) { SpendableOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(SpendableOutputDescriptor)); return *this; }
+       LDKSpendableOutputDescriptor* operator &() { return &self; }
+       LDKSpendableOutputDescriptor* operator ->() { return &self; }
+       const LDKSpendableOutputDescriptor* operator &() const { return &self; }
+       const LDKSpendableOutputDescriptor* operator ->() const { return &self; }
+};
+class BaseSign {
+private:
+       LDKBaseSign self;
+public:
+       BaseSign(const BaseSign&) = delete;
+       BaseSign(BaseSign&& o) : self(o.self) { memset(&o, 0, sizeof(BaseSign)); }
+       BaseSign(LDKBaseSign&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBaseSign)); }
+       operator LDKBaseSign() && { LDKBaseSign res = self; memset(&self, 0, sizeof(LDKBaseSign)); return res; }
+       ~BaseSign() { BaseSign_free(self); }
+       BaseSign& operator=(BaseSign&& o) { BaseSign_free(self); self = o.self; memset(&o, 0, sizeof(BaseSign)); return *this; }
+       LDKBaseSign* operator &() { return &self; }
+       LDKBaseSign* operator ->() { return &self; }
+       const LDKBaseSign* operator &() const { return &self; }
+       const LDKBaseSign* operator ->() const { return &self; }
+};
+class Sign {
+private:
+       LDKSign self;
+public:
+       Sign(const Sign&) = delete;
+       Sign(Sign&& o) : self(o.self) { memset(&o, 0, sizeof(Sign)); }
+       Sign(LDKSign&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSign)); }
+       operator LDKSign() && { LDKSign res = self; memset(&self, 0, sizeof(LDKSign)); return res; }
+       ~Sign() { Sign_free(self); }
+       Sign& operator=(Sign&& o) { Sign_free(self); self = o.self; memset(&o, 0, sizeof(Sign)); return *this; }
+       LDKSign* operator &() { return &self; }
+       LDKSign* operator ->() { return &self; }
+       const LDKSign* operator &() const { return &self; }
+       const LDKSign* operator ->() const { return &self; }
+};
+class KeysInterface {
+private:
+       LDKKeysInterface self;
+public:
+       KeysInterface(const KeysInterface&) = delete;
+       KeysInterface(KeysInterface&& o) : self(o.self) { memset(&o, 0, sizeof(KeysInterface)); }
+       KeysInterface(LDKKeysInterface&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKKeysInterface)); }
+       operator LDKKeysInterface() && { LDKKeysInterface res = self; memset(&self, 0, sizeof(LDKKeysInterface)); return res; }
+       ~KeysInterface() { KeysInterface_free(self); }
+       KeysInterface& operator=(KeysInterface&& o) { KeysInterface_free(self); self = o.self; memset(&o, 0, sizeof(KeysInterface)); return *this; }
+       LDKKeysInterface* operator &() { return &self; }
+       LDKKeysInterface* operator ->() { return &self; }
+       const LDKKeysInterface* operator &() const { return &self; }
+       const LDKKeysInterface* operator ->() const { return &self; }
+};
+class InMemorySigner {
+private:
+       LDKInMemorySigner self;
+public:
+       InMemorySigner(const InMemorySigner&) = delete;
+       InMemorySigner(InMemorySigner&& o) : self(o.self) { memset(&o, 0, sizeof(InMemorySigner)); }
+       InMemorySigner(LDKInMemorySigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInMemorySigner)); }
+       operator LDKInMemorySigner() && { LDKInMemorySigner res = self; memset(&self, 0, sizeof(LDKInMemorySigner)); return res; }
+       ~InMemorySigner() { InMemorySigner_free(self); }
+       InMemorySigner& operator=(InMemorySigner&& o) { InMemorySigner_free(self); self = o.self; memset(&o, 0, sizeof(InMemorySigner)); return *this; }
+       LDKInMemorySigner* operator &() { return &self; }
+       LDKInMemorySigner* operator ->() { return &self; }
+       const LDKInMemorySigner* operator &() const { return &self; }
+       const LDKInMemorySigner* operator ->() const { return &self; }
+};
+class KeysManager {
+private:
+       LDKKeysManager self;
+public:
+       KeysManager(const KeysManager&) = delete;
+       KeysManager(KeysManager&& o) : self(o.self) { memset(&o, 0, sizeof(KeysManager)); }
+       KeysManager(LDKKeysManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKKeysManager)); }
+       operator LDKKeysManager() && { LDKKeysManager res = self; memset(&self, 0, sizeof(LDKKeysManager)); return res; }
+       ~KeysManager() { KeysManager_free(self); }
+       KeysManager& operator=(KeysManager&& o) { KeysManager_free(self); self = o.self; memset(&o, 0, sizeof(KeysManager)); return *this; }
+       LDKKeysManager* operator &() { return &self; }
+       LDKKeysManager* operator ->() { return &self; }
+       const LDKKeysManager* operator &() const { return &self; }
+       const LDKKeysManager* operator ->() const { return &self; }
+};
+class FilesystemPersister {
+private:
+       LDKFilesystemPersister self;
+public:
+       FilesystemPersister(const FilesystemPersister&) = delete;
+       FilesystemPersister(FilesystemPersister&& o) : self(o.self) { memset(&o, 0, sizeof(FilesystemPersister)); }
+       FilesystemPersister(LDKFilesystemPersister&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFilesystemPersister)); }
+       operator LDKFilesystemPersister() && { LDKFilesystemPersister res = self; memset(&self, 0, sizeof(LDKFilesystemPersister)); return res; }
+       ~FilesystemPersister() { FilesystemPersister_free(self); }
+       FilesystemPersister& operator=(FilesystemPersister&& o) { FilesystemPersister_free(self); self = o.self; memset(&o, 0, sizeof(FilesystemPersister)); return *this; }
+       LDKFilesystemPersister* operator &() { return &self; }
+       LDKFilesystemPersister* operator ->() { return &self; }
+       const LDKFilesystemPersister* operator &() const { return &self; }
+       const LDKFilesystemPersister* operator ->() const { return &self; }
+};
+class ChannelManager {
+private:
+       LDKChannelManager self;
+public:
+       ChannelManager(const ChannelManager&) = delete;
+       ChannelManager(ChannelManager&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelManager)); }
+       ChannelManager(LDKChannelManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelManager)); }
+       operator LDKChannelManager() && { LDKChannelManager res = self; memset(&self, 0, sizeof(LDKChannelManager)); return res; }
+       ~ChannelManager() { ChannelManager_free(self); }
+       ChannelManager& operator=(ChannelManager&& o) { ChannelManager_free(self); self = o.self; memset(&o, 0, sizeof(ChannelManager)); return *this; }
+       LDKChannelManager* operator &() { return &self; }
+       LDKChannelManager* operator ->() { return &self; }
+       const LDKChannelManager* operator &() const { return &self; }
+       const LDKChannelManager* operator ->() const { return &self; }
+};
+class ChainParameters {
+private:
+       LDKChainParameters self;
+public:
+       ChainParameters(const ChainParameters&) = delete;
+       ChainParameters(ChainParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ChainParameters)); }
+       ChainParameters(LDKChainParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChainParameters)); }
+       operator LDKChainParameters() && { LDKChainParameters res = self; memset(&self, 0, sizeof(LDKChainParameters)); return res; }
+       ~ChainParameters() { ChainParameters_free(self); }
+       ChainParameters& operator=(ChainParameters&& o) { ChainParameters_free(self); self = o.self; memset(&o, 0, sizeof(ChainParameters)); return *this; }
+       LDKChainParameters* operator &() { return &self; }
+       LDKChainParameters* operator ->() { return &self; }
+       const LDKChainParameters* operator &() const { return &self; }
+       const LDKChainParameters* operator ->() const { return &self; }
+};
+class BestBlock {
+private:
+       LDKBestBlock self;
+public:
+       BestBlock(const BestBlock&) = delete;
+       BestBlock(BestBlock&& o) : self(o.self) { memset(&o, 0, sizeof(BestBlock)); }
+       BestBlock(LDKBestBlock&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBestBlock)); }
+       operator LDKBestBlock() && { LDKBestBlock res = self; memset(&self, 0, sizeof(LDKBestBlock)); return res; }
+       ~BestBlock() { BestBlock_free(self); }
+       BestBlock& operator=(BestBlock&& o) { BestBlock_free(self); self = o.self; memset(&o, 0, sizeof(BestBlock)); return *this; }
+       LDKBestBlock* operator &() { return &self; }
+       LDKBestBlock* operator ->() { return &self; }
+       const LDKBestBlock* operator &() const { return &self; }
+       const LDKBestBlock* operator ->() const { return &self; }
+};
+class ChannelDetails {
+private:
+       LDKChannelDetails self;
+public:
+       ChannelDetails(const ChannelDetails&) = delete;
+       ChannelDetails(ChannelDetails&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelDetails)); }
+       ChannelDetails(LDKChannelDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelDetails)); }
+       operator LDKChannelDetails() && { LDKChannelDetails res = self; memset(&self, 0, sizeof(LDKChannelDetails)); return res; }
+       ~ChannelDetails() { ChannelDetails_free(self); }
+       ChannelDetails& operator=(ChannelDetails&& o) { ChannelDetails_free(self); self = o.self; memset(&o, 0, sizeof(ChannelDetails)); return *this; }
+       LDKChannelDetails* operator &() { return &self; }
+       LDKChannelDetails* operator ->() { return &self; }
+       const LDKChannelDetails* operator &() const { return &self; }
+       const LDKChannelDetails* operator ->() const { return &self; }
+};
+class PaymentSendFailure {
+private:
+       LDKPaymentSendFailure self;
+public:
+       PaymentSendFailure(const PaymentSendFailure&) = delete;
+       PaymentSendFailure(PaymentSendFailure&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentSendFailure)); }
+       PaymentSendFailure(LDKPaymentSendFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentSendFailure)); }
+       operator LDKPaymentSendFailure() && { LDKPaymentSendFailure res = self; memset(&self, 0, sizeof(LDKPaymentSendFailure)); return res; }
+       ~PaymentSendFailure() { PaymentSendFailure_free(self); }
+       PaymentSendFailure& operator=(PaymentSendFailure&& o) { PaymentSendFailure_free(self); self = o.self; memset(&o, 0, sizeof(PaymentSendFailure)); return *this; }
+       LDKPaymentSendFailure* operator &() { return &self; }
+       LDKPaymentSendFailure* operator ->() { return &self; }
+       const LDKPaymentSendFailure* operator &() const { return &self; }
+       const LDKPaymentSendFailure* operator ->() const { return &self; }
+};
+class ChannelManagerReadArgs {
+private:
+       LDKChannelManagerReadArgs self;
+public:
+       ChannelManagerReadArgs(const ChannelManagerReadArgs&) = delete;
+       ChannelManagerReadArgs(ChannelManagerReadArgs&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelManagerReadArgs)); }
+       ChannelManagerReadArgs(LDKChannelManagerReadArgs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelManagerReadArgs)); }
+       operator LDKChannelManagerReadArgs() && { LDKChannelManagerReadArgs res = self; memset(&self, 0, sizeof(LDKChannelManagerReadArgs)); return res; }
+       ~ChannelManagerReadArgs() { ChannelManagerReadArgs_free(self); }
+       ChannelManagerReadArgs& operator=(ChannelManagerReadArgs&& o) { ChannelManagerReadArgs_free(self); self = o.self; memset(&o, 0, sizeof(ChannelManagerReadArgs)); return *this; }
+       LDKChannelManagerReadArgs* operator &() { return &self; }
+       LDKChannelManagerReadArgs* operator ->() { return &self; }
+       const LDKChannelManagerReadArgs* operator &() const { return &self; }
+       const LDKChannelManagerReadArgs* operator ->() const { return &self; }
+};
+class ChannelHandshakeConfig {
+private:
+       LDKChannelHandshakeConfig self;
+public:
+       ChannelHandshakeConfig(const ChannelHandshakeConfig&) = delete;
+       ChannelHandshakeConfig(ChannelHandshakeConfig&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelHandshakeConfig)); }
+       ChannelHandshakeConfig(LDKChannelHandshakeConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelHandshakeConfig)); }
+       operator LDKChannelHandshakeConfig() && { LDKChannelHandshakeConfig res = self; memset(&self, 0, sizeof(LDKChannelHandshakeConfig)); return res; }
+       ~ChannelHandshakeConfig() { ChannelHandshakeConfig_free(self); }
+       ChannelHandshakeConfig& operator=(ChannelHandshakeConfig&& o) { ChannelHandshakeConfig_free(self); self = o.self; memset(&o, 0, sizeof(ChannelHandshakeConfig)); return *this; }
+       LDKChannelHandshakeConfig* operator &() { return &self; }
+       LDKChannelHandshakeConfig* operator ->() { return &self; }
+       const LDKChannelHandshakeConfig* operator &() const { return &self; }
+       const LDKChannelHandshakeConfig* operator ->() const { return &self; }
+};
+class ChannelHandshakeLimits {
+private:
+       LDKChannelHandshakeLimits self;
+public:
+       ChannelHandshakeLimits(const ChannelHandshakeLimits&) = delete;
+       ChannelHandshakeLimits(ChannelHandshakeLimits&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelHandshakeLimits)); }
+       ChannelHandshakeLimits(LDKChannelHandshakeLimits&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelHandshakeLimits)); }
+       operator LDKChannelHandshakeLimits() && { LDKChannelHandshakeLimits res = self; memset(&self, 0, sizeof(LDKChannelHandshakeLimits)); return res; }
+       ~ChannelHandshakeLimits() { ChannelHandshakeLimits_free(self); }
+       ChannelHandshakeLimits& operator=(ChannelHandshakeLimits&& o) { ChannelHandshakeLimits_free(self); self = o.self; memset(&o, 0, sizeof(ChannelHandshakeLimits)); return *this; }
+       LDKChannelHandshakeLimits* operator &() { return &self; }
+       LDKChannelHandshakeLimits* operator ->() { return &self; }
+       const LDKChannelHandshakeLimits* operator &() const { return &self; }
+       const LDKChannelHandshakeLimits* operator ->() const { return &self; }
+};
+class ChannelConfig {
+private:
+       LDKChannelConfig self;
+public:
+       ChannelConfig(const ChannelConfig&) = delete;
+       ChannelConfig(ChannelConfig&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelConfig)); }
+       ChannelConfig(LDKChannelConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelConfig)); }
+       operator LDKChannelConfig() && { LDKChannelConfig res = self; memset(&self, 0, sizeof(LDKChannelConfig)); return res; }
+       ~ChannelConfig() { ChannelConfig_free(self); }
+       ChannelConfig& operator=(ChannelConfig&& o) { ChannelConfig_free(self); self = o.self; memset(&o, 0, sizeof(ChannelConfig)); return *this; }
+       LDKChannelConfig* operator &() { return &self; }
+       LDKChannelConfig* operator ->() { return &self; }
+       const LDKChannelConfig* operator &() const { return &self; }
+       const LDKChannelConfig* operator ->() const { return &self; }
+};
+class UserConfig {
+private:
+       LDKUserConfig self;
+public:
+       UserConfig(const UserConfig&) = delete;
+       UserConfig(UserConfig&& o) : self(o.self) { memset(&o, 0, sizeof(UserConfig)); }
+       UserConfig(LDKUserConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUserConfig)); }
+       operator LDKUserConfig() && { LDKUserConfig res = self; memset(&self, 0, sizeof(LDKUserConfig)); return res; }
+       ~UserConfig() { UserConfig_free(self); }
+       UserConfig& operator=(UserConfig&& o) { UserConfig_free(self); self = o.self; memset(&o, 0, sizeof(UserConfig)); return *this; }
+       LDKUserConfig* operator &() { return &self; }
+       LDKUserConfig* operator ->() { return &self; }
+       const LDKUserConfig* operator &() const { return &self; }
+       const LDKUserConfig* operator ->() const { return &self; }
+};
+class APIError {
+private:
+       LDKAPIError self;
+public:
+       APIError(const APIError&) = delete;
+       APIError(APIError&& o) : self(o.self) { memset(&o, 0, sizeof(APIError)); }
+       APIError(LDKAPIError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAPIError)); }
+       operator LDKAPIError() && { LDKAPIError res = self; memset(&self, 0, sizeof(LDKAPIError)); return res; }
+       ~APIError() { APIError_free(self); }
+       APIError& operator=(APIError&& o) { APIError_free(self); self = o.self; memset(&o, 0, sizeof(APIError)); return *this; }
+       LDKAPIError* operator &() { return &self; }
+       LDKAPIError* operator ->() { return &self; }
+       const LDKAPIError* operator &() const { return &self; }
+       const LDKAPIError* operator ->() const { return &self; }
+};
+class OutPoint {
+private:
+       LDKOutPoint self;
+public:
+       OutPoint(const OutPoint&) = delete;
+       OutPoint(OutPoint&& o) : self(o.self) { memset(&o, 0, sizeof(OutPoint)); }
+       OutPoint(LDKOutPoint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOutPoint)); }
+       operator LDKOutPoint() && { LDKOutPoint res = self; memset(&self, 0, sizeof(LDKOutPoint)); return res; }
+       ~OutPoint() { OutPoint_free(self); }
+       OutPoint& operator=(OutPoint&& o) { OutPoint_free(self); self = o.self; memset(&o, 0, sizeof(OutPoint)); return *this; }
+       LDKOutPoint* operator &() { return &self; }
+       LDKOutPoint* operator ->() { return &self; }
+       const LDKOutPoint* operator &() const { return &self; }
+       const LDKOutPoint* operator ->() const { return &self; }
+};
+class Invoice {
+private:
+       LDKInvoice self;
+public:
+       Invoice(const Invoice&) = delete;
+       Invoice(Invoice&& o) : self(o.self) { memset(&o, 0, sizeof(Invoice)); }
+       Invoice(LDKInvoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoice)); }
+       operator LDKInvoice() && { LDKInvoice res = self; memset(&self, 0, sizeof(LDKInvoice)); return res; }
+       ~Invoice() { Invoice_free(self); }
+       Invoice& operator=(Invoice&& o) { Invoice_free(self); self = o.self; memset(&o, 0, sizeof(Invoice)); return *this; }
+       LDKInvoice* operator &() { return &self; }
+       LDKInvoice* operator ->() { return &self; }
+       const LDKInvoice* operator &() const { return &self; }
+       const LDKInvoice* operator ->() const { return &self; }
+};
+class SignedRawInvoice {
+private:
+       LDKSignedRawInvoice self;
+public:
+       SignedRawInvoice(const SignedRawInvoice&) = delete;
+       SignedRawInvoice(SignedRawInvoice&& o) : self(o.self) { memset(&o, 0, sizeof(SignedRawInvoice)); }
+       SignedRawInvoice(LDKSignedRawInvoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignedRawInvoice)); }
+       operator LDKSignedRawInvoice() && { LDKSignedRawInvoice res = self; memset(&self, 0, sizeof(LDKSignedRawInvoice)); return res; }
+       ~SignedRawInvoice() { SignedRawInvoice_free(self); }
+       SignedRawInvoice& operator=(SignedRawInvoice&& o) { SignedRawInvoice_free(self); self = o.self; memset(&o, 0, sizeof(SignedRawInvoice)); return *this; }
+       LDKSignedRawInvoice* operator &() { return &self; }
+       LDKSignedRawInvoice* operator ->() { return &self; }
+       const LDKSignedRawInvoice* operator &() const { return &self; }
+       const LDKSignedRawInvoice* operator ->() const { return &self; }
 };
-class MonitorUpdateError {
+class RawInvoice {
 private:
-       LDKMonitorUpdateError self;
+       LDKRawInvoice self;
 public:
-       MonitorUpdateError(const MonitorUpdateError&) = delete;
-       MonitorUpdateError(MonitorUpdateError&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorUpdateError)); }
-       MonitorUpdateError(LDKMonitorUpdateError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorUpdateError)); }
-       operator LDKMonitorUpdateError() && { LDKMonitorUpdateError res = self; memset(&self, 0, sizeof(LDKMonitorUpdateError)); return res; }
-       ~MonitorUpdateError() { MonitorUpdateError_free(self); }
-       MonitorUpdateError& operator=(MonitorUpdateError&& o) { MonitorUpdateError_free(self); self = o.self; memset(&o, 0, sizeof(MonitorUpdateError)); return *this; }
-       LDKMonitorUpdateError* operator &() { return &self; }
-       LDKMonitorUpdateError* operator ->() { return &self; }
-       const LDKMonitorUpdateError* operator &() const { return &self; }
-       const LDKMonitorUpdateError* operator ->() const { return &self; }
+       RawInvoice(const RawInvoice&) = delete;
+       RawInvoice(RawInvoice&& o) : self(o.self) { memset(&o, 0, sizeof(RawInvoice)); }
+       RawInvoice(LDKRawInvoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRawInvoice)); }
+       operator LDKRawInvoice() && { LDKRawInvoice res = self; memset(&self, 0, sizeof(LDKRawInvoice)); return res; }
+       ~RawInvoice() { RawInvoice_free(self); }
+       RawInvoice& operator=(RawInvoice&& o) { RawInvoice_free(self); self = o.self; memset(&o, 0, sizeof(RawInvoice)); return *this; }
+       LDKRawInvoice* operator &() { return &self; }
+       LDKRawInvoice* operator ->() { return &self; }
+       const LDKRawInvoice* operator &() const { return &self; }
+       const LDKRawInvoice* operator ->() const { return &self; }
 };
-class MonitorEvent {
+class RawDataPart {
 private:
-       LDKMonitorEvent self;
+       LDKRawDataPart self;
 public:
-       MonitorEvent(const MonitorEvent&) = delete;
-       MonitorEvent(MonitorEvent&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorEvent)); }
-       MonitorEvent(LDKMonitorEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorEvent)); }
-       operator LDKMonitorEvent() && { LDKMonitorEvent res = self; memset(&self, 0, sizeof(LDKMonitorEvent)); return res; }
-       ~MonitorEvent() { MonitorEvent_free(self); }
-       MonitorEvent& operator=(MonitorEvent&& o) { MonitorEvent_free(self); self = o.self; memset(&o, 0, sizeof(MonitorEvent)); return *this; }
-       LDKMonitorEvent* operator &() { return &self; }
-       LDKMonitorEvent* operator ->() { return &self; }
-       const LDKMonitorEvent* operator &() const { return &self; }
-       const LDKMonitorEvent* operator ->() const { return &self; }
+       RawDataPart(const RawDataPart&) = delete;
+       RawDataPart(RawDataPart&& o) : self(o.self) { memset(&o, 0, sizeof(RawDataPart)); }
+       RawDataPart(LDKRawDataPart&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRawDataPart)); }
+       operator LDKRawDataPart() && { LDKRawDataPart res = self; memset(&self, 0, sizeof(LDKRawDataPart)); return res; }
+       ~RawDataPart() { RawDataPart_free(self); }
+       RawDataPart& operator=(RawDataPart&& o) { RawDataPart_free(self); self = o.self; memset(&o, 0, sizeof(RawDataPart)); return *this; }
+       LDKRawDataPart* operator &() { return &self; }
+       LDKRawDataPart* operator ->() { return &self; }
+       const LDKRawDataPart* operator &() const { return &self; }
+       const LDKRawDataPart* operator ->() const { return &self; }
 };
-class HTLCUpdate {
+class PositiveTimestamp {
 private:
-       LDKHTLCUpdate self;
+       LDKPositiveTimestamp self;
 public:
-       HTLCUpdate(const HTLCUpdate&) = delete;
-       HTLCUpdate(HTLCUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCUpdate)); }
-       HTLCUpdate(LDKHTLCUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCUpdate)); }
-       operator LDKHTLCUpdate() && { LDKHTLCUpdate res = self; memset(&self, 0, sizeof(LDKHTLCUpdate)); return res; }
-       ~HTLCUpdate() { HTLCUpdate_free(self); }
-       HTLCUpdate& operator=(HTLCUpdate&& o) { HTLCUpdate_free(self); self = o.self; memset(&o, 0, sizeof(HTLCUpdate)); return *this; }
-       LDKHTLCUpdate* operator &() { return &self; }
-       LDKHTLCUpdate* operator ->() { return &self; }
-       const LDKHTLCUpdate* operator &() const { return &self; }
-       const LDKHTLCUpdate* operator ->() const { return &self; }
+       PositiveTimestamp(const PositiveTimestamp&) = delete;
+       PositiveTimestamp(PositiveTimestamp&& o) : self(o.self) { memset(&o, 0, sizeof(PositiveTimestamp)); }
+       PositiveTimestamp(LDKPositiveTimestamp&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPositiveTimestamp)); }
+       operator LDKPositiveTimestamp() && { LDKPositiveTimestamp res = self; memset(&self, 0, sizeof(LDKPositiveTimestamp)); return res; }
+       ~PositiveTimestamp() { PositiveTimestamp_free(self); }
+       PositiveTimestamp& operator=(PositiveTimestamp&& o) { PositiveTimestamp_free(self); self = o.self; memset(&o, 0, sizeof(PositiveTimestamp)); return *this; }
+       LDKPositiveTimestamp* operator &() { return &self; }
+       LDKPositiveTimestamp* operator ->() { return &self; }
+       const LDKPositiveTimestamp* operator &() const { return &self; }
+       const LDKPositiveTimestamp* operator ->() const { return &self; }
 };
-class ChannelMonitor {
+class SiPrefix {
 private:
-       LDKChannelMonitor self;
+       LDKSiPrefix self;
 public:
-       ChannelMonitor(const ChannelMonitor&) = delete;
-       ChannelMonitor(ChannelMonitor&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitor)); }
-       ChannelMonitor(LDKChannelMonitor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitor)); }
-       operator LDKChannelMonitor() && { LDKChannelMonitor res = self; memset(&self, 0, sizeof(LDKChannelMonitor)); return res; }
-       ~ChannelMonitor() { ChannelMonitor_free(self); }
-       ChannelMonitor& operator=(ChannelMonitor&& o) { ChannelMonitor_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMonitor)); return *this; }
-       LDKChannelMonitor* operator &() { return &self; }
-       LDKChannelMonitor* operator ->() { return &self; }
-       const LDKChannelMonitor* operator &() const { return &self; }
-       const LDKChannelMonitor* operator ->() const { return &self; }
+       SiPrefix(const SiPrefix&) = delete;
+       SiPrefix(SiPrefix&& o) : self(o.self) { memset(&o, 0, sizeof(SiPrefix)); }
+       SiPrefix(LDKSiPrefix&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSiPrefix)); }
+       operator LDKSiPrefix() && { LDKSiPrefix res = self; memset(&self, 0, sizeof(LDKSiPrefix)); return res; }
+       SiPrefix& operator=(SiPrefix&& o) { self = o.self; memset(&o, 0, sizeof(SiPrefix)); return *this; }
+       LDKSiPrefix* operator &() { return &self; }
+       LDKSiPrefix* operator ->() { return &self; }
+       const LDKSiPrefix* operator &() const { return &self; }
+       const LDKSiPrefix* operator ->() const { return &self; }
 };
-class Persist {
+class Currency {
 private:
-       LDKPersist self;
+       LDKCurrency self;
 public:
-       Persist(const Persist&) = delete;
-       Persist(Persist&& o) : self(o.self) { memset(&o, 0, sizeof(Persist)); }
-       Persist(LDKPersist&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPersist)); }
-       operator LDKPersist() && { LDKPersist res = self; memset(&self, 0, sizeof(LDKPersist)); return res; }
-       ~Persist() { Persist_free(self); }
-       Persist& operator=(Persist&& o) { Persist_free(self); self = o.self; memset(&o, 0, sizeof(Persist)); return *this; }
-       LDKPersist* operator &() { return &self; }
-       LDKPersist* operator ->() { return &self; }
-       const LDKPersist* operator &() const { return &self; }
-       const LDKPersist* operator ->() const { return &self; }
+       Currency(const Currency&) = delete;
+       Currency(Currency&& o) : self(o.self) { memset(&o, 0, sizeof(Currency)); }
+       Currency(LDKCurrency&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCurrency)); }
+       operator LDKCurrency() && { LDKCurrency res = self; memset(&self, 0, sizeof(LDKCurrency)); return res; }
+       Currency& operator=(Currency&& o) { self = o.self; memset(&o, 0, sizeof(Currency)); return *this; }
+       LDKCurrency* operator &() { return &self; }
+       LDKCurrency* operator ->() { return &self; }
+       const LDKCurrency* operator &() const { return &self; }
+       const LDKCurrency* operator ->() const { return &self; }
 };
-class RouteHop {
+class Sha256 {
 private:
-       LDKRouteHop self;
+       LDKSha256 self;
 public:
-       RouteHop(const RouteHop&) = delete;
-       RouteHop(RouteHop&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHop)); }
-       RouteHop(LDKRouteHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHop)); }
-       operator LDKRouteHop() && { LDKRouteHop res = self; memset(&self, 0, sizeof(LDKRouteHop)); return res; }
-       ~RouteHop() { RouteHop_free(self); }
-       RouteHop& operator=(RouteHop&& o) { RouteHop_free(self); self = o.self; memset(&o, 0, sizeof(RouteHop)); return *this; }
-       LDKRouteHop* operator &() { return &self; }
-       LDKRouteHop* operator ->() { return &self; }
-       const LDKRouteHop* operator &() const { return &self; }
-       const LDKRouteHop* operator ->() const { return &self; }
+       Sha256(const Sha256&) = delete;
+       Sha256(Sha256&& o) : self(o.self) { memset(&o, 0, sizeof(Sha256)); }
+       Sha256(LDKSha256&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSha256)); }
+       operator LDKSha256() && { LDKSha256 res = self; memset(&self, 0, sizeof(LDKSha256)); return res; }
+       ~Sha256() { Sha256_free(self); }
+       Sha256& operator=(Sha256&& o) { Sha256_free(self); self = o.self; memset(&o, 0, sizeof(Sha256)); return *this; }
+       LDKSha256* operator &() { return &self; }
+       LDKSha256* operator ->() { return &self; }
+       const LDKSha256* operator &() const { return &self; }
+       const LDKSha256* operator ->() const { return &self; }
 };
-class Route {
+class Description {
 private:
-       LDKRoute self;
+       LDKDescription self;
 public:
-       Route(const Route&) = delete;
-       Route(Route&& o) : self(o.self) { memset(&o, 0, sizeof(Route)); }
-       Route(LDKRoute&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoute)); }
-       operator LDKRoute() && { LDKRoute res = self; memset(&self, 0, sizeof(LDKRoute)); return res; }
-       ~Route() { Route_free(self); }
-       Route& operator=(Route&& o) { Route_free(self); self = o.self; memset(&o, 0, sizeof(Route)); return *this; }
-       LDKRoute* operator &() { return &self; }
-       LDKRoute* operator ->() { return &self; }
-       const LDKRoute* operator &() const { return &self; }
-       const LDKRoute* operator ->() const { return &self; }
+       Description(const Description&) = delete;
+       Description(Description&& o) : self(o.self) { memset(&o, 0, sizeof(Description)); }
+       Description(LDKDescription&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDescription)); }
+       operator LDKDescription() && { LDKDescription res = self; memset(&self, 0, sizeof(LDKDescription)); return res; }
+       ~Description() { Description_free(self); }
+       Description& operator=(Description&& o) { Description_free(self); self = o.self; memset(&o, 0, sizeof(Description)); return *this; }
+       LDKDescription* operator &() { return &self; }
+       LDKDescription* operator ->() { return &self; }
+       const LDKDescription* operator &() const { return &self; }
+       const LDKDescription* operator ->() const { return &self; }
 };
-class RouteHintHop {
+class PayeePubKey {
 private:
-       LDKRouteHintHop self;
+       LDKPayeePubKey self;
 public:
-       RouteHintHop(const RouteHintHop&) = delete;
-       RouteHintHop(RouteHintHop&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHintHop)); }
-       RouteHintHop(LDKRouteHintHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHintHop)); }
-       operator LDKRouteHintHop() && { LDKRouteHintHop res = self; memset(&self, 0, sizeof(LDKRouteHintHop)); return res; }
-       ~RouteHintHop() { RouteHintHop_free(self); }
-       RouteHintHop& operator=(RouteHintHop&& o) { RouteHintHop_free(self); self = o.self; memset(&o, 0, sizeof(RouteHintHop)); return *this; }
-       LDKRouteHintHop* operator &() { return &self; }
-       LDKRouteHintHop* operator ->() { return &self; }
-       const LDKRouteHintHop* operator &() const { return &self; }
-       const LDKRouteHintHop* operator ->() const { return &self; }
+       PayeePubKey(const PayeePubKey&) = delete;
+       PayeePubKey(PayeePubKey&& o) : self(o.self) { memset(&o, 0, sizeof(PayeePubKey)); }
+       PayeePubKey(LDKPayeePubKey&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPayeePubKey)); }
+       operator LDKPayeePubKey() && { LDKPayeePubKey res = self; memset(&self, 0, sizeof(LDKPayeePubKey)); return res; }
+       ~PayeePubKey() { PayeePubKey_free(self); }
+       PayeePubKey& operator=(PayeePubKey&& o) { PayeePubKey_free(self); self = o.self; memset(&o, 0, sizeof(PayeePubKey)); return *this; }
+       LDKPayeePubKey* operator &() { return &self; }
+       LDKPayeePubKey* operator ->() { return &self; }
+       const LDKPayeePubKey* operator &() const { return &self; }
+       const LDKPayeePubKey* operator ->() const { return &self; }
 };
-class IgnoringMessageHandler {
+class ExpiryTime {
 private:
-       LDKIgnoringMessageHandler self;
+       LDKExpiryTime self;
 public:
-       IgnoringMessageHandler(const IgnoringMessageHandler&) = delete;
-       IgnoringMessageHandler(IgnoringMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(IgnoringMessageHandler)); }
-       IgnoringMessageHandler(LDKIgnoringMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKIgnoringMessageHandler)); }
-       operator LDKIgnoringMessageHandler() && { LDKIgnoringMessageHandler res = self; memset(&self, 0, sizeof(LDKIgnoringMessageHandler)); return res; }
-       ~IgnoringMessageHandler() { IgnoringMessageHandler_free(self); }
-       IgnoringMessageHandler& operator=(IgnoringMessageHandler&& o) { IgnoringMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(IgnoringMessageHandler)); return *this; }
-       LDKIgnoringMessageHandler* operator &() { return &self; }
-       LDKIgnoringMessageHandler* operator ->() { return &self; }
-       const LDKIgnoringMessageHandler* operator &() const { return &self; }
-       const LDKIgnoringMessageHandler* operator ->() const { return &self; }
+       ExpiryTime(const ExpiryTime&) = delete;
+       ExpiryTime(ExpiryTime&& o) : self(o.self) { memset(&o, 0, sizeof(ExpiryTime)); }
+       ExpiryTime(LDKExpiryTime&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKExpiryTime)); }
+       operator LDKExpiryTime() && { LDKExpiryTime res = self; memset(&self, 0, sizeof(LDKExpiryTime)); return res; }
+       ~ExpiryTime() { ExpiryTime_free(self); }
+       ExpiryTime& operator=(ExpiryTime&& o) { ExpiryTime_free(self); self = o.self; memset(&o, 0, sizeof(ExpiryTime)); return *this; }
+       LDKExpiryTime* operator &() { return &self; }
+       LDKExpiryTime* operator ->() { return &self; }
+       const LDKExpiryTime* operator &() const { return &self; }
+       const LDKExpiryTime* operator ->() const { return &self; }
 };
-class ErroringMessageHandler {
+class MinFinalCltvExpiry {
 private:
-       LDKErroringMessageHandler self;
+       LDKMinFinalCltvExpiry self;
 public:
-       ErroringMessageHandler(const ErroringMessageHandler&) = delete;
-       ErroringMessageHandler(ErroringMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(ErroringMessageHandler)); }
-       ErroringMessageHandler(LDKErroringMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErroringMessageHandler)); }
-       operator LDKErroringMessageHandler() && { LDKErroringMessageHandler res = self; memset(&self, 0, sizeof(LDKErroringMessageHandler)); return res; }
-       ~ErroringMessageHandler() { ErroringMessageHandler_free(self); }
-       ErroringMessageHandler& operator=(ErroringMessageHandler&& o) { ErroringMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(ErroringMessageHandler)); return *this; }
-       LDKErroringMessageHandler* operator &() { return &self; }
-       LDKErroringMessageHandler* operator ->() { return &self; }
-       const LDKErroringMessageHandler* operator &() const { return &self; }
-       const LDKErroringMessageHandler* operator ->() const { return &self; }
+       MinFinalCltvExpiry(const MinFinalCltvExpiry&) = delete;
+       MinFinalCltvExpiry(MinFinalCltvExpiry&& o) : self(o.self) { memset(&o, 0, sizeof(MinFinalCltvExpiry)); }
+       MinFinalCltvExpiry(LDKMinFinalCltvExpiry&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMinFinalCltvExpiry)); }
+       operator LDKMinFinalCltvExpiry() && { LDKMinFinalCltvExpiry res = self; memset(&self, 0, sizeof(LDKMinFinalCltvExpiry)); return res; }
+       ~MinFinalCltvExpiry() { MinFinalCltvExpiry_free(self); }
+       MinFinalCltvExpiry& operator=(MinFinalCltvExpiry&& o) { MinFinalCltvExpiry_free(self); self = o.self; memset(&o, 0, sizeof(MinFinalCltvExpiry)); return *this; }
+       LDKMinFinalCltvExpiry* operator &() { return &self; }
+       LDKMinFinalCltvExpiry* operator ->() { return &self; }
+       const LDKMinFinalCltvExpiry* operator &() const { return &self; }
+       const LDKMinFinalCltvExpiry* operator ->() const { return &self; }
 };
-class MessageHandler {
+class Fallback {
 private:
-       LDKMessageHandler self;
+       LDKFallback self;
 public:
-       MessageHandler(const MessageHandler&) = delete;
-       MessageHandler(MessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(MessageHandler)); }
-       MessageHandler(LDKMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageHandler)); }
-       operator LDKMessageHandler() && { LDKMessageHandler res = self; memset(&self, 0, sizeof(LDKMessageHandler)); return res; }
-       ~MessageHandler() { MessageHandler_free(self); }
-       MessageHandler& operator=(MessageHandler&& o) { MessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(MessageHandler)); return *this; }
-       LDKMessageHandler* operator &() { return &self; }
-       LDKMessageHandler* operator ->() { return &self; }
-       const LDKMessageHandler* operator &() const { return &self; }
-       const LDKMessageHandler* operator ->() const { return &self; }
+       Fallback(const Fallback&) = delete;
+       Fallback(Fallback&& o) : self(o.self) { memset(&o, 0, sizeof(Fallback)); }
+       Fallback(LDKFallback&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFallback)); }
+       operator LDKFallback() && { LDKFallback res = self; memset(&self, 0, sizeof(LDKFallback)); return res; }
+       ~Fallback() { Fallback_free(self); }
+       Fallback& operator=(Fallback&& o) { Fallback_free(self); self = o.self; memset(&o, 0, sizeof(Fallback)); return *this; }
+       LDKFallback* operator &() { return &self; }
+       LDKFallback* operator ->() { return &self; }
+       const LDKFallback* operator &() const { return &self; }
+       const LDKFallback* operator ->() const { return &self; }
 };
-class SocketDescriptor {
+class InvoiceSignature {
 private:
-       LDKSocketDescriptor self;
+       LDKInvoiceSignature self;
 public:
-       SocketDescriptor(const SocketDescriptor&) = delete;
-       SocketDescriptor(SocketDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(SocketDescriptor)); }
-       SocketDescriptor(LDKSocketDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSocketDescriptor)); }
-       operator LDKSocketDescriptor() && { LDKSocketDescriptor res = self; memset(&self, 0, sizeof(LDKSocketDescriptor)); return res; }
-       ~SocketDescriptor() { SocketDescriptor_free(self); }
-       SocketDescriptor& operator=(SocketDescriptor&& o) { SocketDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(SocketDescriptor)); return *this; }
-       LDKSocketDescriptor* operator &() { return &self; }
-       LDKSocketDescriptor* operator ->() { return &self; }
-       const LDKSocketDescriptor* operator &() const { return &self; }
-       const LDKSocketDescriptor* operator ->() const { return &self; }
+       InvoiceSignature(const InvoiceSignature&) = delete;
+       InvoiceSignature(InvoiceSignature&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceSignature)); }
+       InvoiceSignature(LDKInvoiceSignature&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceSignature)); }
+       operator LDKInvoiceSignature() && { LDKInvoiceSignature res = self; memset(&self, 0, sizeof(LDKInvoiceSignature)); return res; }
+       ~InvoiceSignature() { InvoiceSignature_free(self); }
+       InvoiceSignature& operator=(InvoiceSignature&& o) { InvoiceSignature_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceSignature)); return *this; }
+       LDKInvoiceSignature* operator &() { return &self; }
+       LDKInvoiceSignature* operator ->() { return &self; }
+       const LDKInvoiceSignature* operator &() const { return &self; }
+       const LDKInvoiceSignature* operator ->() const { return &self; }
 };
-class PeerHandleError {
+class RouteHint {
 private:
-       LDKPeerHandleError self;
+       LDKRouteHint self;
 public:
-       PeerHandleError(const PeerHandleError&) = delete;
-       PeerHandleError(PeerHandleError&& o) : self(o.self) { memset(&o, 0, sizeof(PeerHandleError)); }
-       PeerHandleError(LDKPeerHandleError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeerHandleError)); }
-       operator LDKPeerHandleError() && { LDKPeerHandleError res = self; memset(&self, 0, sizeof(LDKPeerHandleError)); return res; }
-       ~PeerHandleError() { PeerHandleError_free(self); }
-       PeerHandleError& operator=(PeerHandleError&& o) { PeerHandleError_free(self); self = o.self; memset(&o, 0, sizeof(PeerHandleError)); return *this; }
-       LDKPeerHandleError* operator &() { return &self; }
-       LDKPeerHandleError* operator ->() { return &self; }
-       const LDKPeerHandleError* operator &() const { return &self; }
-       const LDKPeerHandleError* operator ->() const { return &self; }
+       RouteHint(const RouteHint&) = delete;
+       RouteHint(RouteHint&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHint)); }
+       RouteHint(LDKRouteHint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHint)); }
+       operator LDKRouteHint() && { LDKRouteHint res = self; memset(&self, 0, sizeof(LDKRouteHint)); return res; }
+       ~RouteHint() { RouteHint_free(self); }
+       RouteHint& operator=(RouteHint&& o) { RouteHint_free(self); self = o.self; memset(&o, 0, sizeof(RouteHint)); return *this; }
+       LDKRouteHint* operator &() { return &self; }
+       LDKRouteHint* operator ->() { return &self; }
+       const LDKRouteHint* operator &() const { return &self; }
+       const LDKRouteHint* operator ->() const { return &self; }
 };
-class PeerManager {
+class CreationError {
 private:
-       LDKPeerManager self;
+       LDKCreationError self;
 public:
-       PeerManager(const PeerManager&) = delete;
-       PeerManager(PeerManager&& o) : self(o.self) { memset(&o, 0, sizeof(PeerManager)); }
-       PeerManager(LDKPeerManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeerManager)); }
-       operator LDKPeerManager() && { LDKPeerManager res = self; memset(&self, 0, sizeof(LDKPeerManager)); return res; }
-       ~PeerManager() { PeerManager_free(self); }
-       PeerManager& operator=(PeerManager&& o) { PeerManager_free(self); self = o.self; memset(&o, 0, sizeof(PeerManager)); return *this; }
-       LDKPeerManager* operator &() { return &self; }
-       LDKPeerManager* operator ->() { return &self; }
-       const LDKPeerManager* operator &() const { return &self; }
-       const LDKPeerManager* operator ->() const { return &self; }
+       CreationError(const CreationError&) = delete;
+       CreationError(CreationError&& o) : self(o.self) { memset(&o, 0, sizeof(CreationError)); }
+       CreationError(LDKCreationError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCreationError)); }
+       operator LDKCreationError() && { LDKCreationError res = self; memset(&self, 0, sizeof(LDKCreationError)); return res; }
+       CreationError& operator=(CreationError&& o) { self = o.self; memset(&o, 0, sizeof(CreationError)); return *this; }
+       LDKCreationError* operator &() { return &self; }
+       LDKCreationError* operator ->() { return &self; }
+       const LDKCreationError* operator &() const { return &self; }
+       const LDKCreationError* operator ->() const { return &self; }
 };
-class BroadcasterInterface {
+class SemanticError {
 private:
-       LDKBroadcasterInterface self;
+       LDKSemanticError self;
 public:
-       BroadcasterInterface(const BroadcasterInterface&) = delete;
-       BroadcasterInterface(BroadcasterInterface&& o) : self(o.self) { memset(&o, 0, sizeof(BroadcasterInterface)); }
-       BroadcasterInterface(LDKBroadcasterInterface&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBroadcasterInterface)); }
-       operator LDKBroadcasterInterface() && { LDKBroadcasterInterface res = self; memset(&self, 0, sizeof(LDKBroadcasterInterface)); return res; }
-       ~BroadcasterInterface() { BroadcasterInterface_free(self); }
-       BroadcasterInterface& operator=(BroadcasterInterface&& o) { BroadcasterInterface_free(self); self = o.self; memset(&o, 0, sizeof(BroadcasterInterface)); return *this; }
-       LDKBroadcasterInterface* operator &() { return &self; }
-       LDKBroadcasterInterface* operator ->() { return &self; }
-       const LDKBroadcasterInterface* operator &() const { return &self; }
-       const LDKBroadcasterInterface* operator ->() const { return &self; }
+       SemanticError(const SemanticError&) = delete;
+       SemanticError(SemanticError&& o) : self(o.self) { memset(&o, 0, sizeof(SemanticError)); }
+       SemanticError(LDKSemanticError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSemanticError)); }
+       operator LDKSemanticError() && { LDKSemanticError res = self; memset(&self, 0, sizeof(LDKSemanticError)); return res; }
+       SemanticError& operator=(SemanticError&& o) { self = o.self; memset(&o, 0, sizeof(SemanticError)); return *this; }
+       LDKSemanticError* operator &() { return &self; }
+       LDKSemanticError* operator ->() { return &self; }
+       const LDKSemanticError* operator &() const { return &self; }
+       const LDKSemanticError* operator ->() const { return &self; }
 };
-class ConfirmationTarget {
+class SignOrCreationError {
 private:
-       LDKConfirmationTarget self;
+       LDKSignOrCreationError self;
 public:
-       ConfirmationTarget(const ConfirmationTarget&) = delete;
-       ConfirmationTarget(ConfirmationTarget&& o) : self(o.self) { memset(&o, 0, sizeof(ConfirmationTarget)); }
-       ConfirmationTarget(LDKConfirmationTarget&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKConfirmationTarget)); }
-       operator LDKConfirmationTarget() && { LDKConfirmationTarget res = self; memset(&self, 0, sizeof(LDKConfirmationTarget)); return res; }
-       ConfirmationTarget& operator=(ConfirmationTarget&& o) { self = o.self; memset(&o, 0, sizeof(ConfirmationTarget)); return *this; }
-       LDKConfirmationTarget* operator &() { return &self; }
-       LDKConfirmationTarget* operator ->() { return &self; }
-       const LDKConfirmationTarget* operator &() const { return &self; }
-       const LDKConfirmationTarget* operator ->() const { return &self; }
+       SignOrCreationError(const SignOrCreationError&) = delete;
+       SignOrCreationError(SignOrCreationError&& o) : self(o.self) { memset(&o, 0, sizeof(SignOrCreationError)); }
+       SignOrCreationError(LDKSignOrCreationError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignOrCreationError)); }
+       operator LDKSignOrCreationError() && { LDKSignOrCreationError res = self; memset(&self, 0, sizeof(LDKSignOrCreationError)); return res; }
+       ~SignOrCreationError() { SignOrCreationError_free(self); }
+       SignOrCreationError& operator=(SignOrCreationError&& o) { SignOrCreationError_free(self); self = o.self; memset(&o, 0, sizeof(SignOrCreationError)); return *this; }
+       LDKSignOrCreationError* operator &() { return &self; }
+       LDKSignOrCreationError* operator ->() { return &self; }
+       const LDKSignOrCreationError* operator &() const { return &self; }
+       const LDKSignOrCreationError* operator ->() const { return &self; }
 };
-class FeeEstimator {
+class ChannelMonitorUpdate {
 private:
-       LDKFeeEstimator self;
+       LDKChannelMonitorUpdate self;
 public:
-       FeeEstimator(const FeeEstimator&) = delete;
-       FeeEstimator(FeeEstimator&& o) : self(o.self) { memset(&o, 0, sizeof(FeeEstimator)); }
-       FeeEstimator(LDKFeeEstimator&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFeeEstimator)); }
-       operator LDKFeeEstimator() && { LDKFeeEstimator res = self; memset(&self, 0, sizeof(LDKFeeEstimator)); return res; }
-       ~FeeEstimator() { FeeEstimator_free(self); }
-       FeeEstimator& operator=(FeeEstimator&& o) { FeeEstimator_free(self); self = o.self; memset(&o, 0, sizeof(FeeEstimator)); return *this; }
-       LDKFeeEstimator* operator &() { return &self; }
-       LDKFeeEstimator* operator ->() { return &self; }
-       const LDKFeeEstimator* operator &() const { return &self; }
-       const LDKFeeEstimator* operator ->() const { return &self; }
+       ChannelMonitorUpdate(const ChannelMonitorUpdate&) = delete;
+       ChannelMonitorUpdate(ChannelMonitorUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitorUpdate)); }
+       ChannelMonitorUpdate(LDKChannelMonitorUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitorUpdate)); }
+       operator LDKChannelMonitorUpdate() && { LDKChannelMonitorUpdate res = self; memset(&self, 0, sizeof(LDKChannelMonitorUpdate)); return res; }
+       ~ChannelMonitorUpdate() { ChannelMonitorUpdate_free(self); }
+       ChannelMonitorUpdate& operator=(ChannelMonitorUpdate&& o) { ChannelMonitorUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMonitorUpdate)); return *this; }
+       LDKChannelMonitorUpdate* operator &() { return &self; }
+       LDKChannelMonitorUpdate* operator ->() { return &self; }
+       const LDKChannelMonitorUpdate* operator &() const { return &self; }
+       const LDKChannelMonitorUpdate* operator ->() const { return &self; }
 };
-class AccessError {
+class ChannelMonitorUpdateErr {
 private:
-       LDKAccessError self;
+       LDKChannelMonitorUpdateErr self;
 public:
-       AccessError(const AccessError&) = delete;
-       AccessError(AccessError&& o) : self(o.self) { memset(&o, 0, sizeof(AccessError)); }
-       AccessError(LDKAccessError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAccessError)); }
-       operator LDKAccessError() && { LDKAccessError res = self; memset(&self, 0, sizeof(LDKAccessError)); return res; }
-       AccessError& operator=(AccessError&& o) { self = o.self; memset(&o, 0, sizeof(AccessError)); return *this; }
-       LDKAccessError* operator &() { return &self; }
-       LDKAccessError* operator ->() { return &self; }
-       const LDKAccessError* operator &() const { return &self; }
-       const LDKAccessError* operator ->() const { return &self; }
+       ChannelMonitorUpdateErr(const ChannelMonitorUpdateErr&) = delete;
+       ChannelMonitorUpdateErr(ChannelMonitorUpdateErr&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitorUpdateErr)); }
+       ChannelMonitorUpdateErr(LDKChannelMonitorUpdateErr&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitorUpdateErr)); }
+       operator LDKChannelMonitorUpdateErr() && { LDKChannelMonitorUpdateErr res = self; memset(&self, 0, sizeof(LDKChannelMonitorUpdateErr)); return res; }
+       ChannelMonitorUpdateErr& operator=(ChannelMonitorUpdateErr&& o) { self = o.self; memset(&o, 0, sizeof(ChannelMonitorUpdateErr)); return *this; }
+       LDKChannelMonitorUpdateErr* operator &() { return &self; }
+       LDKChannelMonitorUpdateErr* operator ->() { return &self; }
+       const LDKChannelMonitorUpdateErr* operator &() const { return &self; }
+       const LDKChannelMonitorUpdateErr* operator ->() const { return &self; }
 };
-class Access {
+class MonitorUpdateError {
 private:
-       LDKAccess self;
+       LDKMonitorUpdateError self;
 public:
-       Access(const Access&) = delete;
-       Access(Access&& o) : self(o.self) { memset(&o, 0, sizeof(Access)); }
-       Access(LDKAccess&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAccess)); }
-       operator LDKAccess() && { LDKAccess res = self; memset(&self, 0, sizeof(LDKAccess)); return res; }
-       ~Access() { Access_free(self); }
-       Access& operator=(Access&& o) { Access_free(self); self = o.self; memset(&o, 0, sizeof(Access)); return *this; }
-       LDKAccess* operator &() { return &self; }
-       LDKAccess* operator ->() { return &self; }
-       const LDKAccess* operator &() const { return &self; }
-       const LDKAccess* operator ->() const { return &self; }
+       MonitorUpdateError(const MonitorUpdateError&) = delete;
+       MonitorUpdateError(MonitorUpdateError&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorUpdateError)); }
+       MonitorUpdateError(LDKMonitorUpdateError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorUpdateError)); }
+       operator LDKMonitorUpdateError() && { LDKMonitorUpdateError res = self; memset(&self, 0, sizeof(LDKMonitorUpdateError)); return res; }
+       ~MonitorUpdateError() { MonitorUpdateError_free(self); }
+       MonitorUpdateError& operator=(MonitorUpdateError&& o) { MonitorUpdateError_free(self); self = o.self; memset(&o, 0, sizeof(MonitorUpdateError)); return *this; }
+       LDKMonitorUpdateError* operator &() { return &self; }
+       LDKMonitorUpdateError* operator ->() { return &self; }
+       const LDKMonitorUpdateError* operator &() const { return &self; }
+       const LDKMonitorUpdateError* operator ->() const { return &self; }
 };
-class Listen {
+class MonitorEvent {
 private:
-       LDKListen self;
+       LDKMonitorEvent self;
 public:
-       Listen(const Listen&) = delete;
-       Listen(Listen&& o) : self(o.self) { memset(&o, 0, sizeof(Listen)); }
-       Listen(LDKListen&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKListen)); }
-       operator LDKListen() && { LDKListen res = self; memset(&self, 0, sizeof(LDKListen)); return res; }
-       ~Listen() { Listen_free(self); }
-       Listen& operator=(Listen&& o) { Listen_free(self); self = o.self; memset(&o, 0, sizeof(Listen)); return *this; }
-       LDKListen* operator &() { return &self; }
-       LDKListen* operator ->() { return &self; }
-       const LDKListen* operator &() const { return &self; }
-       const LDKListen* operator ->() const { return &self; }
+       MonitorEvent(const MonitorEvent&) = delete;
+       MonitorEvent(MonitorEvent&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorEvent)); }
+       MonitorEvent(LDKMonitorEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorEvent)); }
+       operator LDKMonitorEvent() && { LDKMonitorEvent res = self; memset(&self, 0, sizeof(LDKMonitorEvent)); return res; }
+       ~MonitorEvent() { MonitorEvent_free(self); }
+       MonitorEvent& operator=(MonitorEvent&& o) { MonitorEvent_free(self); self = o.self; memset(&o, 0, sizeof(MonitorEvent)); return *this; }
+       LDKMonitorEvent* operator &() { return &self; }
+       LDKMonitorEvent* operator ->() { return &self; }
+       const LDKMonitorEvent* operator &() const { return &self; }
+       const LDKMonitorEvent* operator ->() const { return &self; }
 };
-class Confirm {
+class HTLCUpdate {
 private:
-       LDKConfirm self;
+       LDKHTLCUpdate self;
 public:
-       Confirm(const Confirm&) = delete;
-       Confirm(Confirm&& o) : self(o.self) { memset(&o, 0, sizeof(Confirm)); }
-       Confirm(LDKConfirm&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKConfirm)); }
-       operator LDKConfirm() && { LDKConfirm res = self; memset(&self, 0, sizeof(LDKConfirm)); return res; }
-       ~Confirm() { Confirm_free(self); }
-       Confirm& operator=(Confirm&& o) { Confirm_free(self); self = o.self; memset(&o, 0, sizeof(Confirm)); return *this; }
-       LDKConfirm* operator &() { return &self; }
-       LDKConfirm* operator ->() { return &self; }
-       const LDKConfirm* operator &() const { return &self; }
-       const LDKConfirm* operator ->() const { return &self; }
+       HTLCUpdate(const HTLCUpdate&) = delete;
+       HTLCUpdate(HTLCUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCUpdate)); }
+       HTLCUpdate(LDKHTLCUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCUpdate)); }
+       operator LDKHTLCUpdate() && { LDKHTLCUpdate res = self; memset(&self, 0, sizeof(LDKHTLCUpdate)); return res; }
+       ~HTLCUpdate() { HTLCUpdate_free(self); }
+       HTLCUpdate& operator=(HTLCUpdate&& o) { HTLCUpdate_free(self); self = o.self; memset(&o, 0, sizeof(HTLCUpdate)); return *this; }
+       LDKHTLCUpdate* operator &() { return &self; }
+       LDKHTLCUpdate* operator ->() { return &self; }
+       const LDKHTLCUpdate* operator &() const { return &self; }
+       const LDKHTLCUpdate* operator ->() const { return &self; }
 };
-class Watch {
+class ChannelMonitor {
 private:
-       LDKWatch self;
-public:
-       Watch(const Watch&) = delete;
-       Watch(Watch&& o) : self(o.self) { memset(&o, 0, sizeof(Watch)); }
-       Watch(LDKWatch&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWatch)); }
-       operator LDKWatch() && { LDKWatch res = self; memset(&self, 0, sizeof(LDKWatch)); return res; }
-       ~Watch() { Watch_free(self); }
-       Watch& operator=(Watch&& o) { Watch_free(self); self = o.self; memset(&o, 0, sizeof(Watch)); return *this; }
-       LDKWatch* operator &() { return &self; }
-       LDKWatch* operator ->() { return &self; }
-       const LDKWatch* operator &() const { return &self; }
-       const LDKWatch* operator ->() const { return &self; }
+       LDKChannelMonitor self;
+public:
+       ChannelMonitor(const ChannelMonitor&) = delete;
+       ChannelMonitor(ChannelMonitor&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitor)); }
+       ChannelMonitor(LDKChannelMonitor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitor)); }
+       operator LDKChannelMonitor() && { LDKChannelMonitor res = self; memset(&self, 0, sizeof(LDKChannelMonitor)); return res; }
+       ~ChannelMonitor() { ChannelMonitor_free(self); }
+       ChannelMonitor& operator=(ChannelMonitor&& o) { ChannelMonitor_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMonitor)); return *this; }
+       LDKChannelMonitor* operator &() { return &self; }
+       LDKChannelMonitor* operator ->() { return &self; }
+       const LDKChannelMonitor* operator &() const { return &self; }
+       const LDKChannelMonitor* operator ->() const { return &self; }
 };
-class Filter {
+class Persist {
 private:
-       LDKFilter self;
+       LDKPersist self;
 public:
-       Filter(const Filter&) = delete;
-       Filter(Filter&& o) : self(o.self) { memset(&o, 0, sizeof(Filter)); }
-       Filter(LDKFilter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFilter)); }
-       operator LDKFilter() && { LDKFilter res = self; memset(&self, 0, sizeof(LDKFilter)); return res; }
-       ~Filter() { Filter_free(self); }
-       Filter& operator=(Filter&& o) { Filter_free(self); self = o.self; memset(&o, 0, sizeof(Filter)); return *this; }
-       LDKFilter* operator &() { return &self; }
-       LDKFilter* operator ->() { return &self; }
-       const LDKFilter* operator &() const { return &self; }
-       const LDKFilter* operator ->() const { return &self; }
+       Persist(const Persist&) = delete;
+       Persist(Persist&& o) : self(o.self) { memset(&o, 0, sizeof(Persist)); }
+       Persist(LDKPersist&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPersist)); }
+       operator LDKPersist() && { LDKPersist res = self; memset(&self, 0, sizeof(LDKPersist)); return res; }
+       ~Persist() { Persist_free(self); }
+       Persist& operator=(Persist&& o) { Persist_free(self); self = o.self; memset(&o, 0, sizeof(Persist)); return *this; }
+       LDKPersist* operator &() { return &self; }
+       LDKPersist* operator ->() { return &self; }
+       const LDKPersist* operator &() const { return &self; }
+       const LDKPersist* operator ->() const { return &self; }
 };
-class WatchedOutput {
+class IgnoringMessageHandler {
 private:
-       LDKWatchedOutput self;
+       LDKIgnoringMessageHandler self;
 public:
-       WatchedOutput(const WatchedOutput&) = delete;
-       WatchedOutput(WatchedOutput&& o) : self(o.self) { memset(&o, 0, sizeof(WatchedOutput)); }
-       WatchedOutput(LDKWatchedOutput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWatchedOutput)); }
-       operator LDKWatchedOutput() && { LDKWatchedOutput res = self; memset(&self, 0, sizeof(LDKWatchedOutput)); return res; }
-       ~WatchedOutput() { WatchedOutput_free(self); }
-       WatchedOutput& operator=(WatchedOutput&& o) { WatchedOutput_free(self); self = o.self; memset(&o, 0, sizeof(WatchedOutput)); return *this; }
-       LDKWatchedOutput* operator &() { return &self; }
-       LDKWatchedOutput* operator ->() { return &self; }
-       const LDKWatchedOutput* operator &() const { return &self; }
-       const LDKWatchedOutput* operator ->() const { return &self; }
+       IgnoringMessageHandler(const IgnoringMessageHandler&) = delete;
+       IgnoringMessageHandler(IgnoringMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(IgnoringMessageHandler)); }
+       IgnoringMessageHandler(LDKIgnoringMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKIgnoringMessageHandler)); }
+       operator LDKIgnoringMessageHandler() && { LDKIgnoringMessageHandler res = self; memset(&self, 0, sizeof(LDKIgnoringMessageHandler)); return res; }
+       ~IgnoringMessageHandler() { IgnoringMessageHandler_free(self); }
+       IgnoringMessageHandler& operator=(IgnoringMessageHandler&& o) { IgnoringMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(IgnoringMessageHandler)); return *this; }
+       LDKIgnoringMessageHandler* operator &() { return &self; }
+       LDKIgnoringMessageHandler* operator ->() { return &self; }
+       const LDKIgnoringMessageHandler* operator &() const { return &self; }
+       const LDKIgnoringMessageHandler* operator ->() const { return &self; }
 };
-class Event {
+class ErroringMessageHandler {
 private:
-       LDKEvent self;
+       LDKErroringMessageHandler self;
 public:
-       Event(const Event&) = delete;
-       Event(Event&& o) : self(o.self) { memset(&o, 0, sizeof(Event)); }
-       Event(LDKEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEvent)); }
-       operator LDKEvent() && { LDKEvent res = self; memset(&self, 0, sizeof(LDKEvent)); return res; }
-       ~Event() { Event_free(self); }
-       Event& operator=(Event&& o) { Event_free(self); self = o.self; memset(&o, 0, sizeof(Event)); return *this; }
-       LDKEvent* operator &() { return &self; }
-       LDKEvent* operator ->() { return &self; }
-       const LDKEvent* operator &() const { return &self; }
-       const LDKEvent* operator ->() const { return &self; }
+       ErroringMessageHandler(const ErroringMessageHandler&) = delete;
+       ErroringMessageHandler(ErroringMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(ErroringMessageHandler)); }
+       ErroringMessageHandler(LDKErroringMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErroringMessageHandler)); }
+       operator LDKErroringMessageHandler() && { LDKErroringMessageHandler res = self; memset(&self, 0, sizeof(LDKErroringMessageHandler)); return res; }
+       ~ErroringMessageHandler() { ErroringMessageHandler_free(self); }
+       ErroringMessageHandler& operator=(ErroringMessageHandler&& o) { ErroringMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(ErroringMessageHandler)); return *this; }
+       LDKErroringMessageHandler* operator &() { return &self; }
+       LDKErroringMessageHandler* operator ->() { return &self; }
+       const LDKErroringMessageHandler* operator &() const { return &self; }
+       const LDKErroringMessageHandler* operator ->() const { return &self; }
 };
-class MessageSendEvent {
+class MessageHandler {
 private:
-       LDKMessageSendEvent self;
+       LDKMessageHandler self;
 public:
-       MessageSendEvent(const MessageSendEvent&) = delete;
-       MessageSendEvent(MessageSendEvent&& o) : self(o.self) { memset(&o, 0, sizeof(MessageSendEvent)); }
-       MessageSendEvent(LDKMessageSendEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageSendEvent)); }
-       operator LDKMessageSendEvent() && { LDKMessageSendEvent res = self; memset(&self, 0, sizeof(LDKMessageSendEvent)); return res; }
-       ~MessageSendEvent() { MessageSendEvent_free(self); }
-       MessageSendEvent& operator=(MessageSendEvent&& o) { MessageSendEvent_free(self); self = o.self; memset(&o, 0, sizeof(MessageSendEvent)); return *this; }
-       LDKMessageSendEvent* operator &() { return &self; }
-       LDKMessageSendEvent* operator ->() { return &self; }
-       const LDKMessageSendEvent* operator &() const { return &self; }
-       const LDKMessageSendEvent* operator ->() const { return &self; }
+       MessageHandler(const MessageHandler&) = delete;
+       MessageHandler(MessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(MessageHandler)); }
+       MessageHandler(LDKMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageHandler)); }
+       operator LDKMessageHandler() && { LDKMessageHandler res = self; memset(&self, 0, sizeof(LDKMessageHandler)); return res; }
+       ~MessageHandler() { MessageHandler_free(self); }
+       MessageHandler& operator=(MessageHandler&& o) { MessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(MessageHandler)); return *this; }
+       LDKMessageHandler* operator &() { return &self; }
+       LDKMessageHandler* operator ->() { return &self; }
+       const LDKMessageHandler* operator &() const { return &self; }
+       const LDKMessageHandler* operator ->() const { return &self; }
 };
-class MessageSendEventsProvider {
+class SocketDescriptor {
 private:
-       LDKMessageSendEventsProvider self;
+       LDKSocketDescriptor self;
 public:
-       MessageSendEventsProvider(const MessageSendEventsProvider&) = delete;
-       MessageSendEventsProvider(MessageSendEventsProvider&& o) : self(o.self) { memset(&o, 0, sizeof(MessageSendEventsProvider)); }
-       MessageSendEventsProvider(LDKMessageSendEventsProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageSendEventsProvider)); }
-       operator LDKMessageSendEventsProvider() && { LDKMessageSendEventsProvider res = self; memset(&self, 0, sizeof(LDKMessageSendEventsProvider)); return res; }
-       ~MessageSendEventsProvider() { MessageSendEventsProvider_free(self); }
-       MessageSendEventsProvider& operator=(MessageSendEventsProvider&& o) { MessageSendEventsProvider_free(self); self = o.self; memset(&o, 0, sizeof(MessageSendEventsProvider)); return *this; }
-       LDKMessageSendEventsProvider* operator &() { return &self; }
-       LDKMessageSendEventsProvider* operator ->() { return &self; }
-       const LDKMessageSendEventsProvider* operator &() const { return &self; }
-       const LDKMessageSendEventsProvider* operator ->() const { return &self; }
+       SocketDescriptor(const SocketDescriptor&) = delete;
+       SocketDescriptor(SocketDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(SocketDescriptor)); }
+       SocketDescriptor(LDKSocketDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSocketDescriptor)); }
+       operator LDKSocketDescriptor() && { LDKSocketDescriptor res = self; memset(&self, 0, sizeof(LDKSocketDescriptor)); return res; }
+       ~SocketDescriptor() { SocketDescriptor_free(self); }
+       SocketDescriptor& operator=(SocketDescriptor&& o) { SocketDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(SocketDescriptor)); return *this; }
+       LDKSocketDescriptor* operator &() { return &self; }
+       LDKSocketDescriptor* operator ->() { return &self; }
+       const LDKSocketDescriptor* operator &() const { return &self; }
+       const LDKSocketDescriptor* operator ->() const { return &self; }
 };
-class EventsProvider {
+class PeerHandleError {
 private:
-       LDKEventsProvider self;
+       LDKPeerHandleError self;
 public:
-       EventsProvider(const EventsProvider&) = delete;
-       EventsProvider(EventsProvider&& o) : self(o.self) { memset(&o, 0, sizeof(EventsProvider)); }
-       EventsProvider(LDKEventsProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEventsProvider)); }
-       operator LDKEventsProvider() && { LDKEventsProvider res = self; memset(&self, 0, sizeof(LDKEventsProvider)); return res; }
-       ~EventsProvider() { EventsProvider_free(self); }
-       EventsProvider& operator=(EventsProvider&& o) { EventsProvider_free(self); self = o.self; memset(&o, 0, sizeof(EventsProvider)); return *this; }
-       LDKEventsProvider* operator &() { return &self; }
-       LDKEventsProvider* operator ->() { return &self; }
-       const LDKEventsProvider* operator &() const { return &self; }
-       const LDKEventsProvider* operator ->() const { return &self; }
+       PeerHandleError(const PeerHandleError&) = delete;
+       PeerHandleError(PeerHandleError&& o) : self(o.self) { memset(&o, 0, sizeof(PeerHandleError)); }
+       PeerHandleError(LDKPeerHandleError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeerHandleError)); }
+       operator LDKPeerHandleError() && { LDKPeerHandleError res = self; memset(&self, 0, sizeof(LDKPeerHandleError)); return res; }
+       ~PeerHandleError() { PeerHandleError_free(self); }
+       PeerHandleError& operator=(PeerHandleError&& o) { PeerHandleError_free(self); self = o.self; memset(&o, 0, sizeof(PeerHandleError)); return *this; }
+       LDKPeerHandleError* operator &() { return &self; }
+       LDKPeerHandleError* operator ->() { return &self; }
+       const LDKPeerHandleError* operator &() const { return &self; }
+       const LDKPeerHandleError* operator ->() const { return &self; }
 };
-class EventHandler {
+class PeerManager {
 private:
-       LDKEventHandler self;
+       LDKPeerManager self;
 public:
-       EventHandler(const EventHandler&) = delete;
-       EventHandler(EventHandler&& o) : self(o.self) { memset(&o, 0, sizeof(EventHandler)); }
-       EventHandler(LDKEventHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEventHandler)); }
-       operator LDKEventHandler() && { LDKEventHandler res = self; memset(&self, 0, sizeof(LDKEventHandler)); return res; }
-       ~EventHandler() { EventHandler_free(self); }
-       EventHandler& operator=(EventHandler&& o) { EventHandler_free(self); self = o.self; memset(&o, 0, sizeof(EventHandler)); return *this; }
-       LDKEventHandler* operator &() { return &self; }
-       LDKEventHandler* operator ->() { return &self; }
-       const LDKEventHandler* operator &() const { return &self; }
-       const LDKEventHandler* operator ->() const { return &self; }
+       PeerManager(const PeerManager&) = delete;
+       PeerManager(PeerManager&& o) : self(o.self) { memset(&o, 0, sizeof(PeerManager)); }
+       PeerManager(LDKPeerManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeerManager)); }
+       operator LDKPeerManager() && { LDKPeerManager res = self; memset(&self, 0, sizeof(LDKPeerManager)); return res; }
+       ~PeerManager() { PeerManager_free(self); }
+       PeerManager& operator=(PeerManager&& o) { PeerManager_free(self); self = o.self; memset(&o, 0, sizeof(PeerManager)); return *this; }
+       LDKPeerManager* operator &() { return &self; }
+       LDKPeerManager* operator ->() { return &self; }
+       const LDKPeerManager* operator &() const { return &self; }
+       const LDKPeerManager* operator ->() const { return &self; }
 };
 class NetworkGraph {
 private:
@@ -1070,83 +1385,23 @@ public:
        NodeAnnouncementInfo& operator=(NodeAnnouncementInfo&& o) { NodeAnnouncementInfo_free(self); self = o.self; memset(&o, 0, sizeof(NodeAnnouncementInfo)); return *this; }
        LDKNodeAnnouncementInfo* operator &() { return &self; }
        LDKNodeAnnouncementInfo* operator ->() { return &self; }
-       const LDKNodeAnnouncementInfo* operator &() const { return &self; }
-       const LDKNodeAnnouncementInfo* operator ->() const { return &self; }
-};
-class NodeInfo {
-private:
-       LDKNodeInfo self;
-public:
-       NodeInfo(const NodeInfo&) = delete;
-       NodeInfo(NodeInfo&& o) : self(o.self) { memset(&o, 0, sizeof(NodeInfo)); }
-       NodeInfo(LDKNodeInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeInfo)); }
-       operator LDKNodeInfo() && { LDKNodeInfo res = self; memset(&self, 0, sizeof(LDKNodeInfo)); return res; }
-       ~NodeInfo() { NodeInfo_free(self); }
-       NodeInfo& operator=(NodeInfo&& o) { NodeInfo_free(self); self = o.self; memset(&o, 0, sizeof(NodeInfo)); return *this; }
-       LDKNodeInfo* operator &() { return &self; }
-       LDKNodeInfo* operator ->() { return &self; }
-       const LDKNodeInfo* operator &() const { return &self; }
-       const LDKNodeInfo* operator ->() const { return &self; }
-};
-class InitFeatures {
-private:
-       LDKInitFeatures self;
-public:
-       InitFeatures(const InitFeatures&) = delete;
-       InitFeatures(InitFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(InitFeatures)); }
-       InitFeatures(LDKInitFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInitFeatures)); }
-       operator LDKInitFeatures() && { LDKInitFeatures res = self; memset(&self, 0, sizeof(LDKInitFeatures)); return res; }
-       ~InitFeatures() { InitFeatures_free(self); }
-       InitFeatures& operator=(InitFeatures&& o) { InitFeatures_free(self); self = o.self; memset(&o, 0, sizeof(InitFeatures)); return *this; }
-       LDKInitFeatures* operator &() { return &self; }
-       LDKInitFeatures* operator ->() { return &self; }
-       const LDKInitFeatures* operator &() const { return &self; }
-       const LDKInitFeatures* operator ->() const { return &self; }
-};
-class NodeFeatures {
-private:
-       LDKNodeFeatures self;
-public:
-       NodeFeatures(const NodeFeatures&) = delete;
-       NodeFeatures(NodeFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(NodeFeatures)); }
-       NodeFeatures(LDKNodeFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeFeatures)); }
-       operator LDKNodeFeatures() && { LDKNodeFeatures res = self; memset(&self, 0, sizeof(LDKNodeFeatures)); return res; }
-       ~NodeFeatures() { NodeFeatures_free(self); }
-       NodeFeatures& operator=(NodeFeatures&& o) { NodeFeatures_free(self); self = o.self; memset(&o, 0, sizeof(NodeFeatures)); return *this; }
-       LDKNodeFeatures* operator &() { return &self; }
-       LDKNodeFeatures* operator ->() { return &self; }
-       const LDKNodeFeatures* operator &() const { return &self; }
-       const LDKNodeFeatures* operator ->() const { return &self; }
-};
-class ChannelFeatures {
-private:
-       LDKChannelFeatures self;
-public:
-       ChannelFeatures(const ChannelFeatures&) = delete;
-       ChannelFeatures(ChannelFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelFeatures)); }
-       ChannelFeatures(LDKChannelFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelFeatures)); }
-       operator LDKChannelFeatures() && { LDKChannelFeatures res = self; memset(&self, 0, sizeof(LDKChannelFeatures)); return res; }
-       ~ChannelFeatures() { ChannelFeatures_free(self); }
-       ChannelFeatures& operator=(ChannelFeatures&& o) { ChannelFeatures_free(self); self = o.self; memset(&o, 0, sizeof(ChannelFeatures)); return *this; }
-       LDKChannelFeatures* operator &() { return &self; }
-       LDKChannelFeatures* operator ->() { return &self; }
-       const LDKChannelFeatures* operator &() const { return &self; }
-       const LDKChannelFeatures* operator ->() const { return &self; }
-};
-class InvoiceFeatures {
-private:
-       LDKInvoiceFeatures self;
-public:
-       InvoiceFeatures(const InvoiceFeatures&) = delete;
-       InvoiceFeatures(InvoiceFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceFeatures)); }
-       InvoiceFeatures(LDKInvoiceFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceFeatures)); }
-       operator LDKInvoiceFeatures() && { LDKInvoiceFeatures res = self; memset(&self, 0, sizeof(LDKInvoiceFeatures)); return res; }
-       ~InvoiceFeatures() { InvoiceFeatures_free(self); }
-       InvoiceFeatures& operator=(InvoiceFeatures&& o) { InvoiceFeatures_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceFeatures)); return *this; }
-       LDKInvoiceFeatures* operator &() { return &self; }
-       LDKInvoiceFeatures* operator ->() { return &self; }
-       const LDKInvoiceFeatures* operator &() const { return &self; }
-       const LDKInvoiceFeatures* operator ->() const { return &self; }
+       const LDKNodeAnnouncementInfo* operator &() const { return &self; }
+       const LDKNodeAnnouncementInfo* operator ->() const { return &self; }
+};
+class NodeInfo {
+private:
+       LDKNodeInfo self;
+public:
+       NodeInfo(const NodeInfo&) = delete;
+       NodeInfo(NodeInfo&& o) : self(o.self) { memset(&o, 0, sizeof(NodeInfo)); }
+       NodeInfo(LDKNodeInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeInfo)); }
+       operator LDKNodeInfo() && { LDKNodeInfo res = self; memset(&self, 0, sizeof(LDKNodeInfo)); return res; }
+       ~NodeInfo() { NodeInfo_free(self); }
+       NodeInfo& operator=(NodeInfo&& o) { NodeInfo_free(self); self = o.self; memset(&o, 0, sizeof(NodeInfo)); return *this; }
+       LDKNodeInfo* operator &() { return &self; }
+       LDKNodeInfo* operator ->() { return &self; }
+       const LDKNodeInfo* operator &() const { return &self; }
+       const LDKNodeInfo* operator ->() const { return &self; }
 };
 class DecodeError {
 private:
@@ -1777,245 +2032,20 @@ public:
        const LDKLogger* operator &() const { return &self; }
        const LDKLogger* operator ->() const { return &self; }
 };
-class DelayedPaymentOutputDescriptor {
-private:
-       LDKDelayedPaymentOutputDescriptor self;
-public:
-       DelayedPaymentOutputDescriptor(const DelayedPaymentOutputDescriptor&) = delete;
-       DelayedPaymentOutputDescriptor(DelayedPaymentOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(DelayedPaymentOutputDescriptor)); }
-       DelayedPaymentOutputDescriptor(LDKDelayedPaymentOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDelayedPaymentOutputDescriptor)); }
-       operator LDKDelayedPaymentOutputDescriptor() && { LDKDelayedPaymentOutputDescriptor res = self; memset(&self, 0, sizeof(LDKDelayedPaymentOutputDescriptor)); return res; }
-       ~DelayedPaymentOutputDescriptor() { DelayedPaymentOutputDescriptor_free(self); }
-       DelayedPaymentOutputDescriptor& operator=(DelayedPaymentOutputDescriptor&& o) { DelayedPaymentOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(DelayedPaymentOutputDescriptor)); return *this; }
-       LDKDelayedPaymentOutputDescriptor* operator &() { return &self; }
-       LDKDelayedPaymentOutputDescriptor* operator ->() { return &self; }
-       const LDKDelayedPaymentOutputDescriptor* operator &() const { return &self; }
-       const LDKDelayedPaymentOutputDescriptor* operator ->() const { return &self; }
-};
-class StaticPaymentOutputDescriptor {
-private:
-       LDKStaticPaymentOutputDescriptor self;
-public:
-       StaticPaymentOutputDescriptor(const StaticPaymentOutputDescriptor&) = delete;
-       StaticPaymentOutputDescriptor(StaticPaymentOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(StaticPaymentOutputDescriptor)); }
-       StaticPaymentOutputDescriptor(LDKStaticPaymentOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKStaticPaymentOutputDescriptor)); }
-       operator LDKStaticPaymentOutputDescriptor() && { LDKStaticPaymentOutputDescriptor res = self; memset(&self, 0, sizeof(LDKStaticPaymentOutputDescriptor)); return res; }
-       ~StaticPaymentOutputDescriptor() { StaticPaymentOutputDescriptor_free(self); }
-       StaticPaymentOutputDescriptor& operator=(StaticPaymentOutputDescriptor&& o) { StaticPaymentOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(StaticPaymentOutputDescriptor)); return *this; }
-       LDKStaticPaymentOutputDescriptor* operator &() { return &self; }
-       LDKStaticPaymentOutputDescriptor* operator ->() { return &self; }
-       const LDKStaticPaymentOutputDescriptor* operator &() const { return &self; }
-       const LDKStaticPaymentOutputDescriptor* operator ->() const { return &self; }
-};
-class SpendableOutputDescriptor {
-private:
-       LDKSpendableOutputDescriptor self;
-public:
-       SpendableOutputDescriptor(const SpendableOutputDescriptor&) = delete;
-       SpendableOutputDescriptor(SpendableOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(SpendableOutputDescriptor)); }
-       SpendableOutputDescriptor(LDKSpendableOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSpendableOutputDescriptor)); }
-       operator LDKSpendableOutputDescriptor() && { LDKSpendableOutputDescriptor res = self; memset(&self, 0, sizeof(LDKSpendableOutputDescriptor)); return res; }
-       ~SpendableOutputDescriptor() { SpendableOutputDescriptor_free(self); }
-       SpendableOutputDescriptor& operator=(SpendableOutputDescriptor&& o) { SpendableOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(SpendableOutputDescriptor)); return *this; }
-       LDKSpendableOutputDescriptor* operator &() { return &self; }
-       LDKSpendableOutputDescriptor* operator ->() { return &self; }
-       const LDKSpendableOutputDescriptor* operator &() const { return &self; }
-       const LDKSpendableOutputDescriptor* operator ->() const { return &self; }
-};
-class BaseSign {
-private:
-       LDKBaseSign self;
-public:
-       BaseSign(const BaseSign&) = delete;
-       BaseSign(BaseSign&& o) : self(o.self) { memset(&o, 0, sizeof(BaseSign)); }
-       BaseSign(LDKBaseSign&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBaseSign)); }
-       operator LDKBaseSign() && { LDKBaseSign res = self; memset(&self, 0, sizeof(LDKBaseSign)); return res; }
-       ~BaseSign() { BaseSign_free(self); }
-       BaseSign& operator=(BaseSign&& o) { BaseSign_free(self); self = o.self; memset(&o, 0, sizeof(BaseSign)); return *this; }
-       LDKBaseSign* operator &() { return &self; }
-       LDKBaseSign* operator ->() { return &self; }
-       const LDKBaseSign* operator &() const { return &self; }
-       const LDKBaseSign* operator ->() const { return &self; }
-};
-class Sign {
-private:
-       LDKSign self;
-public:
-       Sign(const Sign&) = delete;
-       Sign(Sign&& o) : self(o.self) { memset(&o, 0, sizeof(Sign)); }
-       Sign(LDKSign&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSign)); }
-       operator LDKSign() && { LDKSign res = self; memset(&self, 0, sizeof(LDKSign)); return res; }
-       ~Sign() { Sign_free(self); }
-       Sign& operator=(Sign&& o) { Sign_free(self); self = o.self; memset(&o, 0, sizeof(Sign)); return *this; }
-       LDKSign* operator &() { return &self; }
-       LDKSign* operator ->() { return &self; }
-       const LDKSign* operator &() const { return &self; }
-       const LDKSign* operator ->() const { return &self; }
-};
-class KeysInterface {
-private:
-       LDKKeysInterface self;
-public:
-       KeysInterface(const KeysInterface&) = delete;
-       KeysInterface(KeysInterface&& o) : self(o.self) { memset(&o, 0, sizeof(KeysInterface)); }
-       KeysInterface(LDKKeysInterface&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKKeysInterface)); }
-       operator LDKKeysInterface() && { LDKKeysInterface res = self; memset(&self, 0, sizeof(LDKKeysInterface)); return res; }
-       ~KeysInterface() { KeysInterface_free(self); }
-       KeysInterface& operator=(KeysInterface&& o) { KeysInterface_free(self); self = o.self; memset(&o, 0, sizeof(KeysInterface)); return *this; }
-       LDKKeysInterface* operator &() { return &self; }
-       LDKKeysInterface* operator ->() { return &self; }
-       const LDKKeysInterface* operator &() const { return &self; }
-       const LDKKeysInterface* operator ->() const { return &self; }
-};
-class InMemorySigner {
-private:
-       LDKInMemorySigner self;
-public:
-       InMemorySigner(const InMemorySigner&) = delete;
-       InMemorySigner(InMemorySigner&& o) : self(o.self) { memset(&o, 0, sizeof(InMemorySigner)); }
-       InMemorySigner(LDKInMemorySigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInMemorySigner)); }
-       operator LDKInMemorySigner() && { LDKInMemorySigner res = self; memset(&self, 0, sizeof(LDKInMemorySigner)); return res; }
-       ~InMemorySigner() { InMemorySigner_free(self); }
-       InMemorySigner& operator=(InMemorySigner&& o) { InMemorySigner_free(self); self = o.self; memset(&o, 0, sizeof(InMemorySigner)); return *this; }
-       LDKInMemorySigner* operator &() { return &self; }
-       LDKInMemorySigner* operator ->() { return &self; }
-       const LDKInMemorySigner* operator &() const { return &self; }
-       const LDKInMemorySigner* operator ->() const { return &self; }
-};
-class KeysManager {
-private:
-       LDKKeysManager self;
-public:
-       KeysManager(const KeysManager&) = delete;
-       KeysManager(KeysManager&& o) : self(o.self) { memset(&o, 0, sizeof(KeysManager)); }
-       KeysManager(LDKKeysManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKKeysManager)); }
-       operator LDKKeysManager() && { LDKKeysManager res = self; memset(&self, 0, sizeof(LDKKeysManager)); return res; }
-       ~KeysManager() { KeysManager_free(self); }
-       KeysManager& operator=(KeysManager&& o) { KeysManager_free(self); self = o.self; memset(&o, 0, sizeof(KeysManager)); return *this; }
-       LDKKeysManager* operator &() { return &self; }
-       LDKKeysManager* operator ->() { return &self; }
-       const LDKKeysManager* operator &() const { return &self; }
-       const LDKKeysManager* operator ->() const { return &self; }
-};
-class ChainMonitor {
-private:
-       LDKChainMonitor self;
-public:
-       ChainMonitor(const ChainMonitor&) = delete;
-       ChainMonitor(ChainMonitor&& o) : self(o.self) { memset(&o, 0, sizeof(ChainMonitor)); }
-       ChainMonitor(LDKChainMonitor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChainMonitor)); }
-       operator LDKChainMonitor() && { LDKChainMonitor res = self; memset(&self, 0, sizeof(LDKChainMonitor)); return res; }
-       ~ChainMonitor() { ChainMonitor_free(self); }
-       ChainMonitor& operator=(ChainMonitor&& o) { ChainMonitor_free(self); self = o.self; memset(&o, 0, sizeof(ChainMonitor)); return *this; }
-       LDKChainMonitor* operator &() { return &self; }
-       LDKChainMonitor* operator ->() { return &self; }
-       const LDKChainMonitor* operator &() const { return &self; }
-       const LDKChainMonitor* operator ->() const { return &self; }
-};
-class FilesystemPersister {
-private:
-       LDKFilesystemPersister self;
-public:
-       FilesystemPersister(const FilesystemPersister&) = delete;
-       FilesystemPersister(FilesystemPersister&& o) : self(o.self) { memset(&o, 0, sizeof(FilesystemPersister)); }
-       FilesystemPersister(LDKFilesystemPersister&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFilesystemPersister)); }
-       operator LDKFilesystemPersister() && { LDKFilesystemPersister res = self; memset(&self, 0, sizeof(LDKFilesystemPersister)); return res; }
-       ~FilesystemPersister() { FilesystemPersister_free(self); }
-       FilesystemPersister& operator=(FilesystemPersister&& o) { FilesystemPersister_free(self); self = o.self; memset(&o, 0, sizeof(FilesystemPersister)); return *this; }
-       LDKFilesystemPersister* operator &() { return &self; }
-       LDKFilesystemPersister* operator ->() { return &self; }
-       const LDKFilesystemPersister* operator &() const { return &self; }
-       const LDKFilesystemPersister* operator ->() const { return &self; }
-};
-class ChannelManager {
-private:
-       LDKChannelManager self;
-public:
-       ChannelManager(const ChannelManager&) = delete;
-       ChannelManager(ChannelManager&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelManager)); }
-       ChannelManager(LDKChannelManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelManager)); }
-       operator LDKChannelManager() && { LDKChannelManager res = self; memset(&self, 0, sizeof(LDKChannelManager)); return res; }
-       ~ChannelManager() { ChannelManager_free(self); }
-       ChannelManager& operator=(ChannelManager&& o) { ChannelManager_free(self); self = o.self; memset(&o, 0, sizeof(ChannelManager)); return *this; }
-       LDKChannelManager* operator &() { return &self; }
-       LDKChannelManager* operator ->() { return &self; }
-       const LDKChannelManager* operator &() const { return &self; }
-       const LDKChannelManager* operator ->() const { return &self; }
-};
-class ChainParameters {
-private:
-       LDKChainParameters self;
-public:
-       ChainParameters(const ChainParameters&) = delete;
-       ChainParameters(ChainParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ChainParameters)); }
-       ChainParameters(LDKChainParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChainParameters)); }
-       operator LDKChainParameters() && { LDKChainParameters res = self; memset(&self, 0, sizeof(LDKChainParameters)); return res; }
-       ~ChainParameters() { ChainParameters_free(self); }
-       ChainParameters& operator=(ChainParameters&& o) { ChainParameters_free(self); self = o.self; memset(&o, 0, sizeof(ChainParameters)); return *this; }
-       LDKChainParameters* operator &() { return &self; }
-       LDKChainParameters* operator ->() { return &self; }
-       const LDKChainParameters* operator &() const { return &self; }
-       const LDKChainParameters* operator ->() const { return &self; }
-};
-class BestBlock {
-private:
-       LDKBestBlock self;
-public:
-       BestBlock(const BestBlock&) = delete;
-       BestBlock(BestBlock&& o) : self(o.self) { memset(&o, 0, sizeof(BestBlock)); }
-       BestBlock(LDKBestBlock&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBestBlock)); }
-       operator LDKBestBlock() && { LDKBestBlock res = self; memset(&self, 0, sizeof(LDKBestBlock)); return res; }
-       ~BestBlock() { BestBlock_free(self); }
-       BestBlock& operator=(BestBlock&& o) { BestBlock_free(self); self = o.self; memset(&o, 0, sizeof(BestBlock)); return *this; }
-       LDKBestBlock* operator &() { return &self; }
-       LDKBestBlock* operator ->() { return &self; }
-       const LDKBestBlock* operator &() const { return &self; }
-       const LDKBestBlock* operator ->() const { return &self; }
-};
-class ChannelDetails {
-private:
-       LDKChannelDetails self;
-public:
-       ChannelDetails(const ChannelDetails&) = delete;
-       ChannelDetails(ChannelDetails&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelDetails)); }
-       ChannelDetails(LDKChannelDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelDetails)); }
-       operator LDKChannelDetails() && { LDKChannelDetails res = self; memset(&self, 0, sizeof(LDKChannelDetails)); return res; }
-       ~ChannelDetails() { ChannelDetails_free(self); }
-       ChannelDetails& operator=(ChannelDetails&& o) { ChannelDetails_free(self); self = o.self; memset(&o, 0, sizeof(ChannelDetails)); return *this; }
-       LDKChannelDetails* operator &() { return &self; }
-       LDKChannelDetails* operator ->() { return &self; }
-       const LDKChannelDetails* operator &() const { return &self; }
-       const LDKChannelDetails* operator ->() const { return &self; }
-};
-class PaymentSendFailure {
-private:
-       LDKPaymentSendFailure self;
-public:
-       PaymentSendFailure(const PaymentSendFailure&) = delete;
-       PaymentSendFailure(PaymentSendFailure&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentSendFailure)); }
-       PaymentSendFailure(LDKPaymentSendFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentSendFailure)); }
-       operator LDKPaymentSendFailure() && { LDKPaymentSendFailure res = self; memset(&self, 0, sizeof(LDKPaymentSendFailure)); return res; }
-       ~PaymentSendFailure() { PaymentSendFailure_free(self); }
-       PaymentSendFailure& operator=(PaymentSendFailure&& o) { PaymentSendFailure_free(self); self = o.self; memset(&o, 0, sizeof(PaymentSendFailure)); return *this; }
-       LDKPaymentSendFailure* operator &() { return &self; }
-       LDKPaymentSendFailure* operator ->() { return &self; }
-       const LDKPaymentSendFailure* operator &() const { return &self; }
-       const LDKPaymentSendFailure* operator ->() const { return &self; }
-};
-class ChannelManagerReadArgs {
-private:
-       LDKChannelManagerReadArgs self;
-public:
-       ChannelManagerReadArgs(const ChannelManagerReadArgs&) = delete;
-       ChannelManagerReadArgs(ChannelManagerReadArgs&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelManagerReadArgs)); }
-       ChannelManagerReadArgs(LDKChannelManagerReadArgs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelManagerReadArgs)); }
-       operator LDKChannelManagerReadArgs() && { LDKChannelManagerReadArgs res = self; memset(&self, 0, sizeof(LDKChannelManagerReadArgs)); return res; }
-       ~ChannelManagerReadArgs() { ChannelManagerReadArgs_free(self); }
-       ChannelManagerReadArgs& operator=(ChannelManagerReadArgs&& o) { ChannelManagerReadArgs_free(self); self = o.self; memset(&o, 0, sizeof(ChannelManagerReadArgs)); return *this; }
-       LDKChannelManagerReadArgs* operator &() { return &self; }
-       LDKChannelManagerReadArgs* operator ->() { return &self; }
-       const LDKChannelManagerReadArgs* operator &() const { return &self; }
-       const LDKChannelManagerReadArgs* operator ->() const { return &self; }
+class ChainMonitor {
+private:
+       LDKChainMonitor self;
+public:
+       ChainMonitor(const ChainMonitor&) = delete;
+       ChainMonitor(ChainMonitor&& o) : self(o.self) { memset(&o, 0, sizeof(ChainMonitor)); }
+       ChainMonitor(LDKChainMonitor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChainMonitor)); }
+       operator LDKChainMonitor() && { LDKChainMonitor res = self; memset(&self, 0, sizeof(LDKChainMonitor)); return res; }
+       ~ChainMonitor() { ChainMonitor_free(self); }
+       ChainMonitor& operator=(ChainMonitor&& o) { ChainMonitor_free(self); self = o.self; memset(&o, 0, sizeof(ChainMonitor)); return *this; }
+       LDKChainMonitor* operator &() { return &self; }
+       LDKChainMonitor* operator ->() { return &self; }
+       const LDKChainMonitor* operator &() const { return &self; }
+       const LDKChainMonitor* operator ->() const { return &self; }
 };
 class CVec_SpendableOutputDescriptorZ {
 private:
@@ -2032,20 +2062,20 @@ public:
        const LDKCVec_SpendableOutputDescriptorZ* operator &() const { return &self; }
        const LDKCVec_SpendableOutputDescriptorZ* operator ->() const { return &self; }
 };
-class CResult_FundingCreatedDecodeErrorZ {
+class CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ {
 private:
-       LDKCResult_FundingCreatedDecodeErrorZ self;
+       LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ self;
 public:
-       CResult_FundingCreatedDecodeErrorZ(const CResult_FundingCreatedDecodeErrorZ&) = delete;
-       CResult_FundingCreatedDecodeErrorZ(CResult_FundingCreatedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FundingCreatedDecodeErrorZ)); }
-       CResult_FundingCreatedDecodeErrorZ(LDKCResult_FundingCreatedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FundingCreatedDecodeErrorZ)); }
-       operator LDKCResult_FundingCreatedDecodeErrorZ() && { LDKCResult_FundingCreatedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FundingCreatedDecodeErrorZ)); return res; }
-       ~CResult_FundingCreatedDecodeErrorZ() { CResult_FundingCreatedDecodeErrorZ_free(self); }
-       CResult_FundingCreatedDecodeErrorZ& operator=(CResult_FundingCreatedDecodeErrorZ&& o) { CResult_FundingCreatedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FundingCreatedDecodeErrorZ)); return *this; }
-       LDKCResult_FundingCreatedDecodeErrorZ* operator &() { return &self; }
-       LDKCResult_FundingCreatedDecodeErrorZ* operator ->() { return &self; }
-       const LDKCResult_FundingCreatedDecodeErrorZ* operator &() const { return &self; }
-       const LDKCResult_FundingCreatedDecodeErrorZ* operator ->() const { return &self; }
+       CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ(const CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ&) = delete;
+       CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ(CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ)); }
+       CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ)); }
+       operator LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ() && { LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ)); return res; }
+       ~CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ() { CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_free(self); }
+       CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ& operator=(CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ&& o) { CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ)); return *this; }
+       LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* operator &() { return &self; }
+       LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* operator ->() { return &self; }
+       const LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* operator &() const { return &self; }
+       const LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* operator ->() const { return &self; }
 };
 class CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ {
 private:
@@ -2077,6 +2107,21 @@ public:
        const LDKCResult_HTLCUpdateDecodeErrorZ* operator &() const { return &self; }
        const LDKCResult_HTLCUpdateDecodeErrorZ* operator ->() const { return &self; }
 };
+class C2Tuple_SignatureCVec_SignatureZZ {
+private:
+       LDKC2Tuple_SignatureCVec_SignatureZZ self;
+public:
+       C2Tuple_SignatureCVec_SignatureZZ(const C2Tuple_SignatureCVec_SignatureZZ&) = delete;
+       C2Tuple_SignatureCVec_SignatureZZ(C2Tuple_SignatureCVec_SignatureZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_SignatureCVec_SignatureZZ)); }
+       C2Tuple_SignatureCVec_SignatureZZ(LDKC2Tuple_SignatureCVec_SignatureZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ)); }
+       operator LDKC2Tuple_SignatureCVec_SignatureZZ() && { LDKC2Tuple_SignatureCVec_SignatureZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ)); return res; }
+       ~C2Tuple_SignatureCVec_SignatureZZ() { C2Tuple_SignatureCVec_SignatureZZ_free(self); }
+       C2Tuple_SignatureCVec_SignatureZZ& operator=(C2Tuple_SignatureCVec_SignatureZZ&& o) { C2Tuple_SignatureCVec_SignatureZZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_SignatureCVec_SignatureZZ)); return *this; }
+       LDKC2Tuple_SignatureCVec_SignatureZZ* operator &() { return &self; }
+       LDKC2Tuple_SignatureCVec_SignatureZZ* operator ->() { return &self; }
+       const LDKC2Tuple_SignatureCVec_SignatureZZ* operator &() const { return &self; }
+       const LDKC2Tuple_SignatureCVec_SignatureZZ* operator ->() const { return &self; }
+};
 class CVec_C2Tuple_u32TxOutZZ {
 private:
        LDKCVec_C2Tuple_u32TxOutZZ self;
@@ -2092,21 +2137,6 @@ public:
        const LDKCVec_C2Tuple_u32TxOutZZ* operator &() const { return &self; }
        const LDKCVec_C2Tuple_u32TxOutZZ* operator ->() const { return &self; }
 };
-class CResult_ChannelAnnouncementDecodeErrorZ {
-private:
-       LDKCResult_ChannelAnnouncementDecodeErrorZ self;
-public:
-       CResult_ChannelAnnouncementDecodeErrorZ(const CResult_ChannelAnnouncementDecodeErrorZ&) = delete;
-       CResult_ChannelAnnouncementDecodeErrorZ(CResult_ChannelAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelAnnouncementDecodeErrorZ)); }
-       CResult_ChannelAnnouncementDecodeErrorZ(LDKCResult_ChannelAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ)); }
-       operator LDKCResult_ChannelAnnouncementDecodeErrorZ() && { LDKCResult_ChannelAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ)); return res; }
-       ~CResult_ChannelAnnouncementDecodeErrorZ() { CResult_ChannelAnnouncementDecodeErrorZ_free(self); }
-       CResult_ChannelAnnouncementDecodeErrorZ& operator=(CResult_ChannelAnnouncementDecodeErrorZ&& o) { CResult_ChannelAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelAnnouncementDecodeErrorZ)); return *this; }
-       LDKCResult_ChannelAnnouncementDecodeErrorZ* operator &() { return &self; }
-       LDKCResult_ChannelAnnouncementDecodeErrorZ* operator ->() { return &self; }
-       const LDKCResult_ChannelAnnouncementDecodeErrorZ* operator &() const { return &self; }
-       const LDKCResult_ChannelAnnouncementDecodeErrorZ* operator ->() const { return &self; }
-};
 class CResult_ChannelInfoDecodeErrorZ {
 private:
        LDKCResult_ChannelInfoDecodeErrorZ self;
@@ -2122,35 +2152,35 @@ public:
        const LDKCResult_ChannelInfoDecodeErrorZ* operator &() const { return &self; }
        const LDKCResult_ChannelInfoDecodeErrorZ* operator ->() const { return &self; }
 };
-class C2Tuple_SignatureCVec_SignatureZZ {
+class CResult_FundingCreatedDecodeErrorZ {
 private:
-       LDKC2Tuple_SignatureCVec_SignatureZZ self;
+       LDKCResult_FundingCreatedDecodeErrorZ self;
 public:
-       C2Tuple_SignatureCVec_SignatureZZ(const C2Tuple_SignatureCVec_SignatureZZ&) = delete;
-       C2Tuple_SignatureCVec_SignatureZZ(C2Tuple_SignatureCVec_SignatureZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_SignatureCVec_SignatureZZ)); }
-       C2Tuple_SignatureCVec_SignatureZZ(LDKC2Tuple_SignatureCVec_SignatureZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ)); }
-       operator LDKC2Tuple_SignatureCVec_SignatureZZ() && { LDKC2Tuple_SignatureCVec_SignatureZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ)); return res; }
-       ~C2Tuple_SignatureCVec_SignatureZZ() { C2Tuple_SignatureCVec_SignatureZZ_free(self); }
-       C2Tuple_SignatureCVec_SignatureZZ& operator=(C2Tuple_SignatureCVec_SignatureZZ&& o) { C2Tuple_SignatureCVec_SignatureZZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_SignatureCVec_SignatureZZ)); return *this; }
-       LDKC2Tuple_SignatureCVec_SignatureZZ* operator &() { return &self; }
-       LDKC2Tuple_SignatureCVec_SignatureZZ* operator ->() { return &self; }
-       const LDKC2Tuple_SignatureCVec_SignatureZZ* operator &() const { return &self; }
-       const LDKC2Tuple_SignatureCVec_SignatureZZ* operator ->() const { return &self; }
+       CResult_FundingCreatedDecodeErrorZ(const CResult_FundingCreatedDecodeErrorZ&) = delete;
+       CResult_FundingCreatedDecodeErrorZ(CResult_FundingCreatedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FundingCreatedDecodeErrorZ)); }
+       CResult_FundingCreatedDecodeErrorZ(LDKCResult_FundingCreatedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FundingCreatedDecodeErrorZ)); }
+       operator LDKCResult_FundingCreatedDecodeErrorZ() && { LDKCResult_FundingCreatedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FundingCreatedDecodeErrorZ)); return res; }
+       ~CResult_FundingCreatedDecodeErrorZ() { CResult_FundingCreatedDecodeErrorZ_free(self); }
+       CResult_FundingCreatedDecodeErrorZ& operator=(CResult_FundingCreatedDecodeErrorZ&& o) { CResult_FundingCreatedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FundingCreatedDecodeErrorZ)); return *this; }
+       LDKCResult_FundingCreatedDecodeErrorZ* operator &() { return &self; }
+       LDKCResult_FundingCreatedDecodeErrorZ* operator ->() { return &self; }
+       const LDKCResult_FundingCreatedDecodeErrorZ* operator &() const { return &self; }
+       const LDKCResult_FundingCreatedDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ {
+class CResult_ChannelAnnouncementDecodeErrorZ {
 private:
-       LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ self;
+       LDKCResult_ChannelAnnouncementDecodeErrorZ self;
 public:
-       CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ(const CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ&) = delete;
-       CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ(CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ)); }
-       CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ)); }
-       operator LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ() && { LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ)); return res; }
-       ~CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ() { CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_free(self); }
-       CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ& operator=(CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ&& o) { CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ)); return *this; }
-       LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* operator &() { return &self; }
-       LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* operator ->() { return &self; }
-       const LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* operator &() const { return &self; }
-       const LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* operator ->() const { return &self; }
+       CResult_ChannelAnnouncementDecodeErrorZ(const CResult_ChannelAnnouncementDecodeErrorZ&) = delete;
+       CResult_ChannelAnnouncementDecodeErrorZ(CResult_ChannelAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelAnnouncementDecodeErrorZ)); }
+       CResult_ChannelAnnouncementDecodeErrorZ(LDKCResult_ChannelAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ)); }
+       operator LDKCResult_ChannelAnnouncementDecodeErrorZ() && { LDKCResult_ChannelAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ)); return res; }
+       ~CResult_ChannelAnnouncementDecodeErrorZ() { CResult_ChannelAnnouncementDecodeErrorZ_free(self); }
+       CResult_ChannelAnnouncementDecodeErrorZ& operator=(CResult_ChannelAnnouncementDecodeErrorZ&& o) { CResult_ChannelAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelAnnouncementDecodeErrorZ)); return *this; }
+       LDKCResult_ChannelAnnouncementDecodeErrorZ* operator &() { return &self; }
+       LDKCResult_ChannelAnnouncementDecodeErrorZ* operator ->() { return &self; }
+       const LDKCResult_ChannelAnnouncementDecodeErrorZ* operator &() const { return &self; }
+       const LDKCResult_ChannelAnnouncementDecodeErrorZ* operator ->() const { return &self; }
 };
 class CResult_PositiveTimestampCreationErrorZ {
 private:
@@ -2182,21 +2212,6 @@ public:
        const LDKCResult_CVec_u8ZPeerHandleErrorZ* operator &() const { return &self; }
        const LDKCResult_CVec_u8ZPeerHandleErrorZ* operator ->() const { return &self; }
 };
-class CResult_ChannelMonitorUpdateDecodeErrorZ {
-private:
-       LDKCResult_ChannelMonitorUpdateDecodeErrorZ self;
-public:
-       CResult_ChannelMonitorUpdateDecodeErrorZ(const CResult_ChannelMonitorUpdateDecodeErrorZ&) = delete;
-       CResult_ChannelMonitorUpdateDecodeErrorZ(CResult_ChannelMonitorUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateDecodeErrorZ)); }
-       CResult_ChannelMonitorUpdateDecodeErrorZ(LDKCResult_ChannelMonitorUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ)); }
-       operator LDKCResult_ChannelMonitorUpdateDecodeErrorZ() && { LDKCResult_ChannelMonitorUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ)); return res; }
-       ~CResult_ChannelMonitorUpdateDecodeErrorZ() { CResult_ChannelMonitorUpdateDecodeErrorZ_free(self); }
-       CResult_ChannelMonitorUpdateDecodeErrorZ& operator=(CResult_ChannelMonitorUpdateDecodeErrorZ&& o) { CResult_ChannelMonitorUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateDecodeErrorZ)); return *this; }
-       LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator &() { return &self; }
-       LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator ->() { return &self; }
-       const LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator &() const { return &self; }
-       const LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator ->() const { return &self; }
-};
 class CResult_InvoiceFeaturesDecodeErrorZ {
 private:
        LDKCResult_InvoiceFeaturesDecodeErrorZ self;
@@ -2212,6 +2227,21 @@ public:
        const LDKCResult_InvoiceFeaturesDecodeErrorZ* operator &() const { return &self; }
        const LDKCResult_InvoiceFeaturesDecodeErrorZ* operator ->() const { return &self; }
 };
+class CResult_ChannelMonitorUpdateDecodeErrorZ {
+private:
+       LDKCResult_ChannelMonitorUpdateDecodeErrorZ self;
+public:
+       CResult_ChannelMonitorUpdateDecodeErrorZ(const CResult_ChannelMonitorUpdateDecodeErrorZ&) = delete;
+       CResult_ChannelMonitorUpdateDecodeErrorZ(CResult_ChannelMonitorUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateDecodeErrorZ)); }
+       CResult_ChannelMonitorUpdateDecodeErrorZ(LDKCResult_ChannelMonitorUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ)); }
+       operator LDKCResult_ChannelMonitorUpdateDecodeErrorZ() && { LDKCResult_ChannelMonitorUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ)); return res; }
+       ~CResult_ChannelMonitorUpdateDecodeErrorZ() { CResult_ChannelMonitorUpdateDecodeErrorZ_free(self); }
+       CResult_ChannelMonitorUpdateDecodeErrorZ& operator=(CResult_ChannelMonitorUpdateDecodeErrorZ&& o) { CResult_ChannelMonitorUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateDecodeErrorZ)); return *this; }
+       LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator &() { return &self; }
+       LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator ->() { return &self; }
+       const LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator &() const { return &self; }
+       const LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator ->() const { return &self; }
+};
 class COption_u64Z {
 private:
        LDKCOption_u64Z self;
@@ -2422,20 +2452,35 @@ public:
        const LDKCResult_CommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
        const LDKCResult_CommitmentTransactionDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_ExpiryTimeCreationErrorZ {
+class COption_C2Tuple_usizeTransactionZZ {
 private:
-       LDKCResult_ExpiryTimeCreationErrorZ self;
+       LDKCOption_C2Tuple_usizeTransactionZZ self;
 public:
-       CResult_ExpiryTimeCreationErrorZ(const CResult_ExpiryTimeCreationErrorZ&) = delete;
-       CResult_ExpiryTimeCreationErrorZ(CResult_ExpiryTimeCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ExpiryTimeCreationErrorZ)); }
-       CResult_ExpiryTimeCreationErrorZ(LDKCResult_ExpiryTimeCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ExpiryTimeCreationErrorZ)); }
-       operator LDKCResult_ExpiryTimeCreationErrorZ() && { LDKCResult_ExpiryTimeCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ExpiryTimeCreationErrorZ)); return res; }
-       ~CResult_ExpiryTimeCreationErrorZ() { CResult_ExpiryTimeCreationErrorZ_free(self); }
-       CResult_ExpiryTimeCreationErrorZ& operator=(CResult_ExpiryTimeCreationErrorZ&& o) { CResult_ExpiryTimeCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ExpiryTimeCreationErrorZ)); return *this; }
-       LDKCResult_ExpiryTimeCreationErrorZ* operator &() { return &self; }
-       LDKCResult_ExpiryTimeCreationErrorZ* operator ->() { return &self; }
-       const LDKCResult_ExpiryTimeCreationErrorZ* operator &() const { return &self; }
-       const LDKCResult_ExpiryTimeCreationErrorZ* operator ->() const { return &self; }
+       COption_C2Tuple_usizeTransactionZZ(const COption_C2Tuple_usizeTransactionZZ&) = delete;
+       COption_C2Tuple_usizeTransactionZZ(COption_C2Tuple_usizeTransactionZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_C2Tuple_usizeTransactionZZ)); }
+       COption_C2Tuple_usizeTransactionZZ(LDKCOption_C2Tuple_usizeTransactionZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_C2Tuple_usizeTransactionZZ)); }
+       operator LDKCOption_C2Tuple_usizeTransactionZZ() && { LDKCOption_C2Tuple_usizeTransactionZZ res = self; memset(&self, 0, sizeof(LDKCOption_C2Tuple_usizeTransactionZZ)); return res; }
+       ~COption_C2Tuple_usizeTransactionZZ() { COption_C2Tuple_usizeTransactionZZ_free(self); }
+       COption_C2Tuple_usizeTransactionZZ& operator=(COption_C2Tuple_usizeTransactionZZ&& o) { COption_C2Tuple_usizeTransactionZZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_C2Tuple_usizeTransactionZZ)); return *this; }
+       LDKCOption_C2Tuple_usizeTransactionZZ* operator &() { return &self; }
+       LDKCOption_C2Tuple_usizeTransactionZZ* operator ->() { return &self; }
+       const LDKCOption_C2Tuple_usizeTransactionZZ* operator &() const { return &self; }
+       const LDKCOption_C2Tuple_usizeTransactionZZ* operator ->() const { return &self; }
+};
+class CResult_TransactionNoneZ {
+private:
+       LDKCResult_TransactionNoneZ self;
+public:
+       CResult_TransactionNoneZ(const CResult_TransactionNoneZ&) = delete;
+       CResult_TransactionNoneZ(CResult_TransactionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TransactionNoneZ)); }
+       CResult_TransactionNoneZ(LDKCResult_TransactionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TransactionNoneZ)); }
+       operator LDKCResult_TransactionNoneZ() && { LDKCResult_TransactionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TransactionNoneZ)); return res; }
+       ~CResult_TransactionNoneZ() { CResult_TransactionNoneZ_free(self); }
+       CResult_TransactionNoneZ& operator=(CResult_TransactionNoneZ&& o) { CResult_TransactionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TransactionNoneZ)); return *this; }
+       LDKCResult_TransactionNoneZ* operator &() { return &self; }
+       LDKCResult_TransactionNoneZ* operator ->() { return &self; }
+       const LDKCResult_TransactionNoneZ* operator &() const { return &self; }
+       const LDKCResult_TransactionNoneZ* operator ->() const { return &self; }
 };
 class CResult_SignedRawInvoiceNoneZ {
 private:
@@ -2452,20 +2497,20 @@ public:
        const LDKCResult_SignedRawInvoiceNoneZ* operator &() const { return &self; }
        const LDKCResult_SignedRawInvoiceNoneZ* operator ->() const { return &self; }
 };
-class COption_C2Tuple_usizeTransactionZZ {
+class CResult_ExpiryTimeCreationErrorZ {
 private:
-       LDKCOption_C2Tuple_usizeTransactionZZ self;
+       LDKCResult_ExpiryTimeCreationErrorZ self;
 public:
-       COption_C2Tuple_usizeTransactionZZ(const COption_C2Tuple_usizeTransactionZZ&) = delete;
-       COption_C2Tuple_usizeTransactionZZ(COption_C2Tuple_usizeTransactionZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_C2Tuple_usizeTransactionZZ)); }
-       COption_C2Tuple_usizeTransactionZZ(LDKCOption_C2Tuple_usizeTransactionZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_C2Tuple_usizeTransactionZZ)); }
-       operator LDKCOption_C2Tuple_usizeTransactionZZ() && { LDKCOption_C2Tuple_usizeTransactionZZ res = self; memset(&self, 0, sizeof(LDKCOption_C2Tuple_usizeTransactionZZ)); return res; }
-       ~COption_C2Tuple_usizeTransactionZZ() { COption_C2Tuple_usizeTransactionZZ_free(self); }
-       COption_C2Tuple_usizeTransactionZZ& operator=(COption_C2Tuple_usizeTransactionZZ&& o) { COption_C2Tuple_usizeTransactionZZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_C2Tuple_usizeTransactionZZ)); return *this; }
-       LDKCOption_C2Tuple_usizeTransactionZZ* operator &() { return &self; }
-       LDKCOption_C2Tuple_usizeTransactionZZ* operator ->() { return &self; }
-       const LDKCOption_C2Tuple_usizeTransactionZZ* operator &() const { return &self; }
-       const LDKCOption_C2Tuple_usizeTransactionZZ* operator ->() const { return &self; }
+       CResult_ExpiryTimeCreationErrorZ(const CResult_ExpiryTimeCreationErrorZ&) = delete;
+       CResult_ExpiryTimeCreationErrorZ(CResult_ExpiryTimeCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ExpiryTimeCreationErrorZ)); }
+       CResult_ExpiryTimeCreationErrorZ(LDKCResult_ExpiryTimeCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ExpiryTimeCreationErrorZ)); }
+       operator LDKCResult_ExpiryTimeCreationErrorZ() && { LDKCResult_ExpiryTimeCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ExpiryTimeCreationErrorZ)); return res; }
+       ~CResult_ExpiryTimeCreationErrorZ() { CResult_ExpiryTimeCreationErrorZ_free(self); }
+       CResult_ExpiryTimeCreationErrorZ& operator=(CResult_ExpiryTimeCreationErrorZ&& o) { CResult_ExpiryTimeCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ExpiryTimeCreationErrorZ)); return *this; }
+       LDKCResult_ExpiryTimeCreationErrorZ* operator &() { return &self; }
+       LDKCResult_ExpiryTimeCreationErrorZ* operator ->() { return &self; }
+       const LDKCResult_ExpiryTimeCreationErrorZ* operator &() const { return &self; }
+       const LDKCResult_ExpiryTimeCreationErrorZ* operator ->() const { return &self; }
 };
 class CResult_PingDecodeErrorZ {
 private:
@@ -2482,21 +2527,6 @@ public:
        const LDKCResult_PingDecodeErrorZ* operator &() const { return &self; }
        const LDKCResult_PingDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_TransactionNoneZ {
-private:
-       LDKCResult_TransactionNoneZ self;
-public:
-       CResult_TransactionNoneZ(const CResult_TransactionNoneZ&) = delete;
-       CResult_TransactionNoneZ(CResult_TransactionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TransactionNoneZ)); }
-       CResult_TransactionNoneZ(LDKCResult_TransactionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TransactionNoneZ)); }
-       operator LDKCResult_TransactionNoneZ() && { LDKCResult_TransactionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TransactionNoneZ)); return res; }
-       ~CResult_TransactionNoneZ() { CResult_TransactionNoneZ_free(self); }
-       CResult_TransactionNoneZ& operator=(CResult_TransactionNoneZ&& o) { CResult_TransactionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TransactionNoneZ)); return *this; }
-       LDKCResult_TransactionNoneZ* operator &() { return &self; }
-       LDKCResult_TransactionNoneZ* operator ->() { return &self; }
-       const LDKCResult_TransactionNoneZ* operator &() const { return &self; }
-       const LDKCResult_TransactionNoneZ* operator ->() const { return &self; }
-};
 class CVec_TransactionOutputsZ {
 private:
        LDKCVec_TransactionOutputsZ self;
@@ -2599,38 +2629,8 @@ public:
        CResult_QueryChannelRangeDecodeErrorZ& operator=(CResult_QueryChannelRangeDecodeErrorZ&& o) { CResult_QueryChannelRangeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_QueryChannelRangeDecodeErrorZ)); return *this; }
        LDKCResult_QueryChannelRangeDecodeErrorZ* operator &() { return &self; }
        LDKCResult_QueryChannelRangeDecodeErrorZ* operator ->() { return &self; }
-       const LDKCResult_QueryChannelRangeDecodeErrorZ* operator &() const { return &self; }
-       const LDKCResult_QueryChannelRangeDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_TxCreationKeysDecodeErrorZ {
-private:
-       LDKCResult_TxCreationKeysDecodeErrorZ self;
-public:
-       CResult_TxCreationKeysDecodeErrorZ(const CResult_TxCreationKeysDecodeErrorZ&) = delete;
-       CResult_TxCreationKeysDecodeErrorZ(CResult_TxCreationKeysDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxCreationKeysDecodeErrorZ)); }
-       CResult_TxCreationKeysDecodeErrorZ(LDKCResult_TxCreationKeysDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxCreationKeysDecodeErrorZ)); }
-       operator LDKCResult_TxCreationKeysDecodeErrorZ() && { LDKCResult_TxCreationKeysDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxCreationKeysDecodeErrorZ)); return res; }
-       ~CResult_TxCreationKeysDecodeErrorZ() { CResult_TxCreationKeysDecodeErrorZ_free(self); }
-       CResult_TxCreationKeysDecodeErrorZ& operator=(CResult_TxCreationKeysDecodeErrorZ&& o) { CResult_TxCreationKeysDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxCreationKeysDecodeErrorZ)); return *this; }
-       LDKCResult_TxCreationKeysDecodeErrorZ* operator &() { return &self; }
-       LDKCResult_TxCreationKeysDecodeErrorZ* operator ->() { return &self; }
-       const LDKCResult_TxCreationKeysDecodeErrorZ* operator &() const { return &self; }
-       const LDKCResult_TxCreationKeysDecodeErrorZ* operator ->() const { return &self; }
-};
-class CVec_TransactionZ {
-private:
-       LDKCVec_TransactionZ self;
-public:
-       CVec_TransactionZ(const CVec_TransactionZ&) = delete;
-       CVec_TransactionZ(CVec_TransactionZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TransactionZ)); }
-       CVec_TransactionZ(LDKCVec_TransactionZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TransactionZ)); }
-       operator LDKCVec_TransactionZ() && { LDKCVec_TransactionZ res = self; memset(&self, 0, sizeof(LDKCVec_TransactionZ)); return res; }
-       ~CVec_TransactionZ() { CVec_TransactionZ_free(self); }
-       CVec_TransactionZ& operator=(CVec_TransactionZ&& o) { CVec_TransactionZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TransactionZ)); return *this; }
-       LDKCVec_TransactionZ* operator &() { return &self; }
-       LDKCVec_TransactionZ* operator ->() { return &self; }
-       const LDKCVec_TransactionZ* operator &() const { return &self; }
-       const LDKCVec_TransactionZ* operator ->() const { return &self; }
+       const LDKCResult_QueryChannelRangeDecodeErrorZ* operator &() const { return &self; }
+       const LDKCResult_QueryChannelRangeDecodeErrorZ* operator ->() const { return &self; }
 };
 class C2Tuple_usizeTransactionZ {
 private:
@@ -2647,6 +2647,21 @@ public:
        const LDKC2Tuple_usizeTransactionZ* operator &() const { return &self; }
        const LDKC2Tuple_usizeTransactionZ* operator ->() const { return &self; }
 };
+class CResult_TxCreationKeysDecodeErrorZ {
+private:
+       LDKCResult_TxCreationKeysDecodeErrorZ self;
+public:
+       CResult_TxCreationKeysDecodeErrorZ(const CResult_TxCreationKeysDecodeErrorZ&) = delete;
+       CResult_TxCreationKeysDecodeErrorZ(CResult_TxCreationKeysDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxCreationKeysDecodeErrorZ)); }
+       CResult_TxCreationKeysDecodeErrorZ(LDKCResult_TxCreationKeysDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxCreationKeysDecodeErrorZ)); }
+       operator LDKCResult_TxCreationKeysDecodeErrorZ() && { LDKCResult_TxCreationKeysDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxCreationKeysDecodeErrorZ)); return res; }
+       ~CResult_TxCreationKeysDecodeErrorZ() { CResult_TxCreationKeysDecodeErrorZ_free(self); }
+       CResult_TxCreationKeysDecodeErrorZ& operator=(CResult_TxCreationKeysDecodeErrorZ&& o) { CResult_TxCreationKeysDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxCreationKeysDecodeErrorZ)); return *this; }
+       LDKCResult_TxCreationKeysDecodeErrorZ* operator &() { return &self; }
+       LDKCResult_TxCreationKeysDecodeErrorZ* operator ->() { return &self; }
+       const LDKCResult_TxCreationKeysDecodeErrorZ* operator &() const { return &self; }
+       const LDKCResult_TxCreationKeysDecodeErrorZ* operator ->() const { return &self; }
+};
 class CResult_ChannelFeaturesDecodeErrorZ {
 private:
        LDKCResult_ChannelFeaturesDecodeErrorZ self;
@@ -2662,20 +2677,35 @@ public:
        const LDKCResult_ChannelFeaturesDecodeErrorZ* operator &() const { return &self; }
        const LDKCResult_ChannelFeaturesDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_NodeAnnouncementDecodeErrorZ {
+class CVec_ChannelMonitorZ {
 private:
-       LDKCResult_NodeAnnouncementDecodeErrorZ self;
+       LDKCVec_ChannelMonitorZ self;
 public:
-       CResult_NodeAnnouncementDecodeErrorZ(const CResult_NodeAnnouncementDecodeErrorZ&) = delete;
-       CResult_NodeAnnouncementDecodeErrorZ(CResult_NodeAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeAnnouncementDecodeErrorZ)); }
-       CResult_NodeAnnouncementDecodeErrorZ(LDKCResult_NodeAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ)); }
-       operator LDKCResult_NodeAnnouncementDecodeErrorZ() && { LDKCResult_NodeAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ)); return res; }
-       ~CResult_NodeAnnouncementDecodeErrorZ() { CResult_NodeAnnouncementDecodeErrorZ_free(self); }
-       CResult_NodeAnnouncementDecodeErrorZ& operator=(CResult_NodeAnnouncementDecodeErrorZ&& o) { CResult_NodeAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeAnnouncementDecodeErrorZ)); return *this; }
-       LDKCResult_NodeAnnouncementDecodeErrorZ* operator &() { return &self; }
-       LDKCResult_NodeAnnouncementDecodeErrorZ* operator ->() { return &self; }
-       const LDKCResult_NodeAnnouncementDecodeErrorZ* operator &() const { return &self; }
-       const LDKCResult_NodeAnnouncementDecodeErrorZ* operator ->() const { return &self; }
+       CVec_ChannelMonitorZ(const CVec_ChannelMonitorZ&) = delete;
+       CVec_ChannelMonitorZ(CVec_ChannelMonitorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ChannelMonitorZ)); }
+       CVec_ChannelMonitorZ(LDKCVec_ChannelMonitorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ChannelMonitorZ)); }
+       operator LDKCVec_ChannelMonitorZ() && { LDKCVec_ChannelMonitorZ res = self; memset(&self, 0, sizeof(LDKCVec_ChannelMonitorZ)); return res; }
+       ~CVec_ChannelMonitorZ() { CVec_ChannelMonitorZ_free(self); }
+       CVec_ChannelMonitorZ& operator=(CVec_ChannelMonitorZ&& o) { CVec_ChannelMonitorZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ChannelMonitorZ)); return *this; }
+       LDKCVec_ChannelMonitorZ* operator &() { return &self; }
+       LDKCVec_ChannelMonitorZ* operator ->() { return &self; }
+       const LDKCVec_ChannelMonitorZ* operator &() const { return &self; }
+       const LDKCVec_ChannelMonitorZ* operator ->() const { return &self; }
+};
+class CVec_TransactionZ {
+private:
+       LDKCVec_TransactionZ self;
+public:
+       CVec_TransactionZ(const CVec_TransactionZ&) = delete;
+       CVec_TransactionZ(CVec_TransactionZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TransactionZ)); }
+       CVec_TransactionZ(LDKCVec_TransactionZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TransactionZ)); }
+       operator LDKCVec_TransactionZ() && { LDKCVec_TransactionZ res = self; memset(&self, 0, sizeof(LDKCVec_TransactionZ)); return res; }
+       ~CVec_TransactionZ() { CVec_TransactionZ_free(self); }
+       CVec_TransactionZ& operator=(CVec_TransactionZ&& o) { CVec_TransactionZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TransactionZ)); return *this; }
+       LDKCVec_TransactionZ* operator &() { return &self; }
+       LDKCVec_TransactionZ* operator ->() { return &self; }
+       const LDKCVec_TransactionZ* operator &() const { return &self; }
+       const LDKCVec_TransactionZ* operator ->() const { return &self; }
 };
 class CResult_UpdateFeeDecodeErrorZ {
 private:
@@ -2707,20 +2737,20 @@ public:
        const LDKCResult_RouteHopDecodeErrorZ* operator &() const { return &self; }
        const LDKCResult_RouteHopDecodeErrorZ* operator ->() const { return &self; }
 };
-class CVec_ChannelMonitorZ {
+class CResult_NodeAnnouncementDecodeErrorZ {
 private:
-       LDKCVec_ChannelMonitorZ self;
+       LDKCResult_NodeAnnouncementDecodeErrorZ self;
 public:
-       CVec_ChannelMonitorZ(const CVec_ChannelMonitorZ&) = delete;
-       CVec_ChannelMonitorZ(CVec_ChannelMonitorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ChannelMonitorZ)); }
-       CVec_ChannelMonitorZ(LDKCVec_ChannelMonitorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ChannelMonitorZ)); }
-       operator LDKCVec_ChannelMonitorZ() && { LDKCVec_ChannelMonitorZ res = self; memset(&self, 0, sizeof(LDKCVec_ChannelMonitorZ)); return res; }
-       ~CVec_ChannelMonitorZ() { CVec_ChannelMonitorZ_free(self); }
-       CVec_ChannelMonitorZ& operator=(CVec_ChannelMonitorZ&& o) { CVec_ChannelMonitorZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ChannelMonitorZ)); return *this; }
-       LDKCVec_ChannelMonitorZ* operator &() { return &self; }
-       LDKCVec_ChannelMonitorZ* operator ->() { return &self; }
-       const LDKCVec_ChannelMonitorZ* operator &() const { return &self; }
-       const LDKCVec_ChannelMonitorZ* operator ->() const { return &self; }
+       CResult_NodeAnnouncementDecodeErrorZ(const CResult_NodeAnnouncementDecodeErrorZ&) = delete;
+       CResult_NodeAnnouncementDecodeErrorZ(CResult_NodeAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeAnnouncementDecodeErrorZ)); }
+       CResult_NodeAnnouncementDecodeErrorZ(LDKCResult_NodeAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ)); }
+       operator LDKCResult_NodeAnnouncementDecodeErrorZ() && { LDKCResult_NodeAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ)); return res; }
+       ~CResult_NodeAnnouncementDecodeErrorZ() { CResult_NodeAnnouncementDecodeErrorZ_free(self); }
+       CResult_NodeAnnouncementDecodeErrorZ& operator=(CResult_NodeAnnouncementDecodeErrorZ&& o) { CResult_NodeAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeAnnouncementDecodeErrorZ)); return *this; }
+       LDKCResult_NodeAnnouncementDecodeErrorZ* operator &() { return &self; }
+       LDKCResult_NodeAnnouncementDecodeErrorZ* operator ->() { return &self; }
+       const LDKCResult_NodeAnnouncementDecodeErrorZ* operator &() const { return &self; }
+       const LDKCResult_NodeAnnouncementDecodeErrorZ* operator ->() const { return &self; }
 };
 class CResult_HTLCOutputInCommitmentDecodeErrorZ {
 private:
@@ -2797,21 +2827,6 @@ public:
        const LDKCResult_FundingSignedDecodeErrorZ* operator &() const { return &self; }
        const LDKCResult_FundingSignedDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_NodeAnnouncementInfoDecodeErrorZ {
-private:
-       LDKCResult_NodeAnnouncementInfoDecodeErrorZ self;
-public:
-       CResult_NodeAnnouncementInfoDecodeErrorZ(const CResult_NodeAnnouncementInfoDecodeErrorZ&) = delete;
-       CResult_NodeAnnouncementInfoDecodeErrorZ(CResult_NodeAnnouncementInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeAnnouncementInfoDecodeErrorZ)); }
-       CResult_NodeAnnouncementInfoDecodeErrorZ(LDKCResult_NodeAnnouncementInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ)); }
-       operator LDKCResult_NodeAnnouncementInfoDecodeErrorZ() && { LDKCResult_NodeAnnouncementInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ)); return res; }
-       ~CResult_NodeAnnouncementInfoDecodeErrorZ() { CResult_NodeAnnouncementInfoDecodeErrorZ_free(self); }
-       CResult_NodeAnnouncementInfoDecodeErrorZ& operator=(CResult_NodeAnnouncementInfoDecodeErrorZ&& o) { CResult_NodeAnnouncementInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeAnnouncementInfoDecodeErrorZ)); return *this; }
-       LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator &() { return &self; }
-       LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator ->() { return &self; }
-       const LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator &() const { return &self; }
-       const LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator ->() const { return &self; }
-};
 class CResult_RecoverableSignatureNoneZ {
 private:
        LDKCResult_RecoverableSignatureNoneZ self;
@@ -2827,6 +2842,21 @@ public:
        const LDKCResult_RecoverableSignatureNoneZ* operator &() const { return &self; }
        const LDKCResult_RecoverableSignatureNoneZ* operator ->() const { return &self; }
 };
+class CResult_NodeAnnouncementInfoDecodeErrorZ {
+private:
+       LDKCResult_NodeAnnouncementInfoDecodeErrorZ self;
+public:
+       CResult_NodeAnnouncementInfoDecodeErrorZ(const CResult_NodeAnnouncementInfoDecodeErrorZ&) = delete;
+       CResult_NodeAnnouncementInfoDecodeErrorZ(CResult_NodeAnnouncementInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeAnnouncementInfoDecodeErrorZ)); }
+       CResult_NodeAnnouncementInfoDecodeErrorZ(LDKCResult_NodeAnnouncementInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ)); }
+       operator LDKCResult_NodeAnnouncementInfoDecodeErrorZ() && { LDKCResult_NodeAnnouncementInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ)); return res; }
+       ~CResult_NodeAnnouncementInfoDecodeErrorZ() { CResult_NodeAnnouncementInfoDecodeErrorZ_free(self); }
+       CResult_NodeAnnouncementInfoDecodeErrorZ& operator=(CResult_NodeAnnouncementInfoDecodeErrorZ&& o) { CResult_NodeAnnouncementInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeAnnouncementInfoDecodeErrorZ)); return *this; }
+       LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator &() { return &self; }
+       LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator ->() { return &self; }
+       const LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator &() const { return &self; }
+       const LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator ->() const { return &self; }
+};
 class CResult_NetAddressu8Z {
 private:
        LDKCResult_NetAddressu8Z self;
@@ -2917,21 +2947,6 @@ public:
        const LDKCResult_RouteHintCreationErrorZ* operator &() const { return &self; }
        const LDKCResult_RouteHintCreationErrorZ* operator ->() const { return &self; }
 };
-class CResult_NodeInfoDecodeErrorZ {
-private:
-       LDKCResult_NodeInfoDecodeErrorZ self;
-public:
-       CResult_NodeInfoDecodeErrorZ(const CResult_NodeInfoDecodeErrorZ&) = delete;
-       CResult_NodeInfoDecodeErrorZ(CResult_NodeInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeInfoDecodeErrorZ)); }
-       CResult_NodeInfoDecodeErrorZ(LDKCResult_NodeInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeInfoDecodeErrorZ)); }
-       operator LDKCResult_NodeInfoDecodeErrorZ() && { LDKCResult_NodeInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeInfoDecodeErrorZ)); return res; }
-       ~CResult_NodeInfoDecodeErrorZ() { CResult_NodeInfoDecodeErrorZ_free(self); }
-       CResult_NodeInfoDecodeErrorZ& operator=(CResult_NodeInfoDecodeErrorZ&& o) { CResult_NodeInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeInfoDecodeErrorZ)); return *this; }
-       LDKCResult_NodeInfoDecodeErrorZ* operator &() { return &self; }
-       LDKCResult_NodeInfoDecodeErrorZ* operator ->() { return &self; }
-       const LDKCResult_NodeInfoDecodeErrorZ* operator &() const { return &self; }
-       const LDKCResult_NodeInfoDecodeErrorZ* operator ->() const { return &self; }
-};
 class CVec_C2Tuple_BlockHashChannelMonitorZZ {
 private:
        LDKCVec_C2Tuple_BlockHashChannelMonitorZZ self;
@@ -2947,20 +2962,35 @@ public:
        const LDKCVec_C2Tuple_BlockHashChannelMonitorZZ* operator &() const { return &self; }
        const LDKCVec_C2Tuple_BlockHashChannelMonitorZZ* operator ->() const { return &self; }
 };
-class CVec_u8Z {
+class CResult_NonePaymentSendFailureZ {
 private:
-       LDKCVec_u8Z self;
+       LDKCResult_NonePaymentSendFailureZ self;
 public:
-       CVec_u8Z(const CVec_u8Z&) = delete;
-       CVec_u8Z(CVec_u8Z&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_u8Z)); }
-       CVec_u8Z(LDKCVec_u8Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_u8Z)); }
-       operator LDKCVec_u8Z() && { LDKCVec_u8Z res = self; memset(&self, 0, sizeof(LDKCVec_u8Z)); return res; }
-       ~CVec_u8Z() { CVec_u8Z_free(self); }
-       CVec_u8Z& operator=(CVec_u8Z&& o) { CVec_u8Z_free(self); self = o.self; memset(&o, 0, sizeof(CVec_u8Z)); return *this; }
-       LDKCVec_u8Z* operator &() { return &self; }
-       LDKCVec_u8Z* operator ->() { return &self; }
-       const LDKCVec_u8Z* operator &() const { return &self; }
-       const LDKCVec_u8Z* operator ->() const { return &self; }
+       CResult_NonePaymentSendFailureZ(const CResult_NonePaymentSendFailureZ&) = delete;
+       CResult_NonePaymentSendFailureZ(CResult_NonePaymentSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NonePaymentSendFailureZ)); }
+       CResult_NonePaymentSendFailureZ(LDKCResult_NonePaymentSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NonePaymentSendFailureZ)); }
+       operator LDKCResult_NonePaymentSendFailureZ() && { LDKCResult_NonePaymentSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_NonePaymentSendFailureZ)); return res; }
+       ~CResult_NonePaymentSendFailureZ() { CResult_NonePaymentSendFailureZ_free(self); }
+       CResult_NonePaymentSendFailureZ& operator=(CResult_NonePaymentSendFailureZ&& o) { CResult_NonePaymentSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NonePaymentSendFailureZ)); return *this; }
+       LDKCResult_NonePaymentSendFailureZ* operator &() { return &self; }
+       LDKCResult_NonePaymentSendFailureZ* operator ->() { return &self; }
+       const LDKCResult_NonePaymentSendFailureZ* operator &() const { return &self; }
+       const LDKCResult_NonePaymentSendFailureZ* operator ->() const { return &self; }
+};
+class CResult_RouteLightningErrorZ {
+private:
+       LDKCResult_RouteLightningErrorZ self;
+public:
+       CResult_RouteLightningErrorZ(const CResult_RouteLightningErrorZ&) = delete;
+       CResult_RouteLightningErrorZ(CResult_RouteLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteLightningErrorZ)); }
+       CResult_RouteLightningErrorZ(LDKCResult_RouteLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteLightningErrorZ)); }
+       operator LDKCResult_RouteLightningErrorZ() && { LDKCResult_RouteLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteLightningErrorZ)); return res; }
+       ~CResult_RouteLightningErrorZ() { CResult_RouteLightningErrorZ_free(self); }
+       CResult_RouteLightningErrorZ& operator=(CResult_RouteLightningErrorZ&& o) { CResult_RouteLightningErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteLightningErrorZ)); return *this; }
+       LDKCResult_RouteLightningErrorZ* operator &() { return &self; }
+       LDKCResult_RouteLightningErrorZ* operator ->() { return &self; }
+       const LDKCResult_RouteLightningErrorZ* operator &() const { return &self; }
+       const LDKCResult_RouteLightningErrorZ* operator ->() const { return &self; }
 };
 class CResult_ChannelPublicKeysDecodeErrorZ {
 private:
@@ -2977,35 +3007,35 @@ public:
        const LDKCResult_ChannelPublicKeysDecodeErrorZ* operator &() const { return &self; }
        const LDKCResult_ChannelPublicKeysDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_RouteLightningErrorZ {
+class CVec_u8Z {
 private:
-       LDKCResult_RouteLightningErrorZ self;
+       LDKCVec_u8Z self;
 public:
-       CResult_RouteLightningErrorZ(const CResult_RouteLightningErrorZ&) = delete;
-       CResult_RouteLightningErrorZ(CResult_RouteLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteLightningErrorZ)); }
-       CResult_RouteLightningErrorZ(LDKCResult_RouteLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteLightningErrorZ)); }
-       operator LDKCResult_RouteLightningErrorZ() && { LDKCResult_RouteLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteLightningErrorZ)); return res; }
-       ~CResult_RouteLightningErrorZ() { CResult_RouteLightningErrorZ_free(self); }
-       CResult_RouteLightningErrorZ& operator=(CResult_RouteLightningErrorZ&& o) { CResult_RouteLightningErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteLightningErrorZ)); return *this; }
-       LDKCResult_RouteLightningErrorZ* operator &() { return &self; }
-       LDKCResult_RouteLightningErrorZ* operator ->() { return &self; }
-       const LDKCResult_RouteLightningErrorZ* operator &() const { return &self; }
-       const LDKCResult_RouteLightningErrorZ* operator ->() const { return &self; }
+       CVec_u8Z(const CVec_u8Z&) = delete;
+       CVec_u8Z(CVec_u8Z&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_u8Z)); }
+       CVec_u8Z(LDKCVec_u8Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_u8Z)); }
+       operator LDKCVec_u8Z() && { LDKCVec_u8Z res = self; memset(&self, 0, sizeof(LDKCVec_u8Z)); return res; }
+       ~CVec_u8Z() { CVec_u8Z_free(self); }
+       CVec_u8Z& operator=(CVec_u8Z&& o) { CVec_u8Z_free(self); self = o.self; memset(&o, 0, sizeof(CVec_u8Z)); return *this; }
+       LDKCVec_u8Z* operator &() { return &self; }
+       LDKCVec_u8Z* operator ->() { return &self; }
+       const LDKCVec_u8Z* operator &() const { return &self; }
+       const LDKCVec_u8Z* operator ->() const { return &self; }
 };
-class CResult_NonePaymentSendFailureZ {
+class CResult_NodeInfoDecodeErrorZ {
 private:
-       LDKCResult_NonePaymentSendFailureZ self;
+       LDKCResult_NodeInfoDecodeErrorZ self;
 public:
-       CResult_NonePaymentSendFailureZ(const CResult_NonePaymentSendFailureZ&) = delete;
-       CResult_NonePaymentSendFailureZ(CResult_NonePaymentSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NonePaymentSendFailureZ)); }
-       CResult_NonePaymentSendFailureZ(LDKCResult_NonePaymentSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NonePaymentSendFailureZ)); }
-       operator LDKCResult_NonePaymentSendFailureZ() && { LDKCResult_NonePaymentSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_NonePaymentSendFailureZ)); return res; }
-       ~CResult_NonePaymentSendFailureZ() { CResult_NonePaymentSendFailureZ_free(self); }
-       CResult_NonePaymentSendFailureZ& operator=(CResult_NonePaymentSendFailureZ&& o) { CResult_NonePaymentSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NonePaymentSendFailureZ)); return *this; }
-       LDKCResult_NonePaymentSendFailureZ* operator &() { return &self; }
-       LDKCResult_NonePaymentSendFailureZ* operator ->() { return &self; }
-       const LDKCResult_NonePaymentSendFailureZ* operator &() const { return &self; }
-       const LDKCResult_NonePaymentSendFailureZ* operator ->() const { return &self; }
+       CResult_NodeInfoDecodeErrorZ(const CResult_NodeInfoDecodeErrorZ&) = delete;
+       CResult_NodeInfoDecodeErrorZ(CResult_NodeInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeInfoDecodeErrorZ)); }
+       CResult_NodeInfoDecodeErrorZ(LDKCResult_NodeInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeInfoDecodeErrorZ)); }
+       operator LDKCResult_NodeInfoDecodeErrorZ() && { LDKCResult_NodeInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeInfoDecodeErrorZ)); return res; }
+       ~CResult_NodeInfoDecodeErrorZ() { CResult_NodeInfoDecodeErrorZ_free(self); }
+       CResult_NodeInfoDecodeErrorZ& operator=(CResult_NodeInfoDecodeErrorZ&& o) { CResult_NodeInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeInfoDecodeErrorZ)); return *this; }
+       LDKCResult_NodeInfoDecodeErrorZ* operator &() { return &self; }
+       LDKCResult_NodeInfoDecodeErrorZ* operator ->() { return &self; }
+       const LDKCResult_NodeInfoDecodeErrorZ* operator &() const { return &self; }
+       const LDKCResult_NodeInfoDecodeErrorZ* operator ->() const { return &self; }
 };
 class CResult_ClosingSignedDecodeErrorZ {
 private:
@@ -3232,21 +3262,6 @@ public:
        const LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator &() const { return &self; }
        const LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_PongDecodeErrorZ {
-private:
-       LDKCResult_PongDecodeErrorZ self;
-public:
-       CResult_PongDecodeErrorZ(const CResult_PongDecodeErrorZ&) = delete;
-       CResult_PongDecodeErrorZ(CResult_PongDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PongDecodeErrorZ)); }
-       CResult_PongDecodeErrorZ(LDKCResult_PongDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PongDecodeErrorZ)); }
-       operator LDKCResult_PongDecodeErrorZ() && { LDKCResult_PongDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PongDecodeErrorZ)); return res; }
-       ~CResult_PongDecodeErrorZ() { CResult_PongDecodeErrorZ_free(self); }
-       CResult_PongDecodeErrorZ& operator=(CResult_PongDecodeErrorZ&& o) { CResult_PongDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PongDecodeErrorZ)); return *this; }
-       LDKCResult_PongDecodeErrorZ* operator &() { return &self; }
-       LDKCResult_PongDecodeErrorZ* operator ->() { return &self; }
-       const LDKCResult_PongDecodeErrorZ* operator &() const { return &self; }
-       const LDKCResult_PongDecodeErrorZ* operator ->() const { return &self; }
-};
 class CVec_TxidZ {
 private:
        LDKCVec_TxidZ self;
@@ -3277,21 +3292,6 @@ public:
        const LDKCResult_NoneMonitorUpdateErrorZ* operator &() const { return &self; }
        const LDKCResult_NoneMonitorUpdateErrorZ* operator ->() const { return &self; }
 };
-class CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
-private:
-       LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ self;
-public:
-       CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(const CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&) = delete;
-       CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); }
-       CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); }
-       operator LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ() && { LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ res = self; memset(&self, 0, sizeof(LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); return res; }
-       ~CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ() { CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(self); }
-       CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ& operator=(CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&& o) { CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); return *this; }
-       LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator &() { return &self; }
-       LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator ->() { return &self; }
-       const LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator &() const { return &self; }
-       const LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator ->() const { return &self; }
-};
 class CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ {
 private:
        LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ self;
@@ -3307,20 +3307,35 @@ public:
        const LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* operator &() const { return &self; }
        const LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* operator ->() const { return &self; }
 };
-class CResult_AcceptChannelDecodeErrorZ {
+class CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ {
+private:
+       LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ self;
+public:
+       CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ(const CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ&) = delete;
+       CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ(CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ)); }
+       CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ)); }
+       operator LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ() && { LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ)); return res; }
+       ~CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ() { CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(self); }
+       CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ& operator=(CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ&& o) { CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ)); return *this; }
+       LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* operator &() { return &self; }
+       LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* operator ->() { return &self; }
+       const LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* operator &() const { return &self; }
+       const LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* operator ->() const { return &self; }
+};
+class CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
 private:
-       LDKCResult_AcceptChannelDecodeErrorZ self;
+       LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ self;
 public:
-       CResult_AcceptChannelDecodeErrorZ(const CResult_AcceptChannelDecodeErrorZ&) = delete;
-       CResult_AcceptChannelDecodeErrorZ(CResult_AcceptChannelDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_AcceptChannelDecodeErrorZ)); }
-       CResult_AcceptChannelDecodeErrorZ(LDKCResult_AcceptChannelDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_AcceptChannelDecodeErrorZ)); }
-       operator LDKCResult_AcceptChannelDecodeErrorZ() && { LDKCResult_AcceptChannelDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_AcceptChannelDecodeErrorZ)); return res; }
-       ~CResult_AcceptChannelDecodeErrorZ() { CResult_AcceptChannelDecodeErrorZ_free(self); }
-       CResult_AcceptChannelDecodeErrorZ& operator=(CResult_AcceptChannelDecodeErrorZ&& o) { CResult_AcceptChannelDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_AcceptChannelDecodeErrorZ)); return *this; }
-       LDKCResult_AcceptChannelDecodeErrorZ* operator &() { return &self; }
-       LDKCResult_AcceptChannelDecodeErrorZ* operator ->() { return &self; }
-       const LDKCResult_AcceptChannelDecodeErrorZ* operator &() const { return &self; }
-       const LDKCResult_AcceptChannelDecodeErrorZ* operator ->() const { return &self; }
+       CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(const CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&) = delete;
+       CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); }
+       CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); }
+       operator LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ() && { LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ res = self; memset(&self, 0, sizeof(LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); return res; }
+       ~CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ() { CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(self); }
+       CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ& operator=(CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&& o) { CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); return *this; }
+       LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator &() { return &self; }
+       LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator ->() { return &self; }
+       const LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator &() const { return &self; }
+       const LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator ->() const { return &self; }
 };
 class CResult_CVec_CVec_u8ZZNoneZ {
 private:
@@ -3352,6 +3367,21 @@ public:
        const LDKC2Tuple_PaymentHashPaymentSecretZ* operator &() const { return &self; }
        const LDKC2Tuple_PaymentHashPaymentSecretZ* operator ->() const { return &self; }
 };
+class CResult_AcceptChannelDecodeErrorZ {
+private:
+       LDKCResult_AcceptChannelDecodeErrorZ self;
+public:
+       CResult_AcceptChannelDecodeErrorZ(const CResult_AcceptChannelDecodeErrorZ&) = delete;
+       CResult_AcceptChannelDecodeErrorZ(CResult_AcceptChannelDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_AcceptChannelDecodeErrorZ)); }
+       CResult_AcceptChannelDecodeErrorZ(LDKCResult_AcceptChannelDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_AcceptChannelDecodeErrorZ)); }
+       operator LDKCResult_AcceptChannelDecodeErrorZ() && { LDKCResult_AcceptChannelDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_AcceptChannelDecodeErrorZ)); return res; }
+       ~CResult_AcceptChannelDecodeErrorZ() { CResult_AcceptChannelDecodeErrorZ_free(self); }
+       CResult_AcceptChannelDecodeErrorZ& operator=(CResult_AcceptChannelDecodeErrorZ&& o) { CResult_AcceptChannelDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_AcceptChannelDecodeErrorZ)); return *this; }
+       LDKCResult_AcceptChannelDecodeErrorZ* operator &() { return &self; }
+       LDKCResult_AcceptChannelDecodeErrorZ* operator ->() { return &self; }
+       const LDKCResult_AcceptChannelDecodeErrorZ* operator &() const { return &self; }
+       const LDKCResult_AcceptChannelDecodeErrorZ* operator ->() const { return &self; }
+};
 class C2Tuple_BlockHashChannelManagerZ {
 private:
        LDKC2Tuple_BlockHashChannelManagerZ self;
@@ -3382,20 +3412,20 @@ public:
        const LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator &() const { return &self; }
        const LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ {
+class CResult_PongDecodeErrorZ {
 private:
-       LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ self;
+       LDKCResult_PongDecodeErrorZ self;
 public:
-       CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ(const CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ&) = delete;
-       CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ(CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ)); }
-       CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ)); }
-       operator LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ() && { LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ)); return res; }
-       ~CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ() { CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(self); }
-       CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ& operator=(CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ&& o) { CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ)); return *this; }
-       LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* operator &() { return &self; }
-       LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* operator ->() { return &self; }
-       const LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* operator &() const { return &self; }
-       const LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* operator ->() const { return &self; }
+       CResult_PongDecodeErrorZ(const CResult_PongDecodeErrorZ&) = delete;
+       CResult_PongDecodeErrorZ(CResult_PongDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PongDecodeErrorZ)); }
+       CResult_PongDecodeErrorZ(LDKCResult_PongDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PongDecodeErrorZ)); }
+       operator LDKCResult_PongDecodeErrorZ() && { LDKCResult_PongDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PongDecodeErrorZ)); return res; }
+       ~CResult_PongDecodeErrorZ() { CResult_PongDecodeErrorZ_free(self); }
+       CResult_PongDecodeErrorZ& operator=(CResult_PongDecodeErrorZ&& o) { CResult_PongDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PongDecodeErrorZ)); return *this; }
+       LDKCResult_PongDecodeErrorZ* operator &() { return &self; }
+       LDKCResult_PongDecodeErrorZ* operator ->() { return &self; }
+       const LDKCResult_PongDecodeErrorZ* operator &() const { return &self; }
+       const LDKCResult_PongDecodeErrorZ* operator ->() const { return &self; }
 };
 class CVec_SignatureZ {
 private:
@@ -3667,21 +3697,6 @@ public:
        const LDKCResult_UpdateAddHTLCDecodeErrorZ* operator &() const { return &self; }
        const LDKCResult_UpdateAddHTLCDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_CounterpartyChannelTransactionParametersDecodeErrorZ {
-private:
-       LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ self;
-public:
-       CResult_CounterpartyChannelTransactionParametersDecodeErrorZ(const CResult_CounterpartyChannelTransactionParametersDecodeErrorZ&) = delete;
-       CResult_CounterpartyChannelTransactionParametersDecodeErrorZ(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); }
-       CResult_CounterpartyChannelTransactionParametersDecodeErrorZ(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); }
-       operator LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ() && { LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); return res; }
-       ~CResult_CounterpartyChannelTransactionParametersDecodeErrorZ() { CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(self); }
-       CResult_CounterpartyChannelTransactionParametersDecodeErrorZ& operator=(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ&& o) { CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); return *this; }
-       LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator &() { return &self; }
-       LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator ->() { return &self; }
-       const LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator &() const { return &self; }
-       const LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator ->() const { return &self; }
-};
 class CResult_NoneAPIErrorZ {
 private:
        LDKCResult_NoneAPIErrorZ self;
@@ -3697,6 +3712,21 @@ public:
        const LDKCResult_NoneAPIErrorZ* operator &() const { return &self; }
        const LDKCResult_NoneAPIErrorZ* operator ->() const { return &self; }
 };
+class CResult_CounterpartyChannelTransactionParametersDecodeErrorZ {
+private:
+       LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ self;
+public:
+       CResult_CounterpartyChannelTransactionParametersDecodeErrorZ(const CResult_CounterpartyChannelTransactionParametersDecodeErrorZ&) = delete;
+       CResult_CounterpartyChannelTransactionParametersDecodeErrorZ(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); }
+       CResult_CounterpartyChannelTransactionParametersDecodeErrorZ(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); }
+       operator LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ() && { LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); return res; }
+       ~CResult_CounterpartyChannelTransactionParametersDecodeErrorZ() { CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(self); }
+       CResult_CounterpartyChannelTransactionParametersDecodeErrorZ& operator=(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ&& o) { CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); return *this; }
+       LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator &() { return &self; }
+       LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator ->() { return &self; }
+       const LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator &() const { return &self; }
+       const LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator ->() const { return &self; }
+};
 class CVec_NetAddressZ {
 private:
        LDKCVec_NetAddressZ self;
@@ -3892,21 +3922,6 @@ public:
        const LDKCResult_NoneSemanticErrorZ* operator &() const { return &self; }
        const LDKCResult_NoneSemanticErrorZ* operator ->() const { return &self; }
 };
-class CVec_C2Tuple_u32ScriptZZ {
-private:
-       LDKCVec_C2Tuple_u32ScriptZZ self;
-public:
-       CVec_C2Tuple_u32ScriptZZ(const CVec_C2Tuple_u32ScriptZZ&) = delete;
-       CVec_C2Tuple_u32ScriptZZ(CVec_C2Tuple_u32ScriptZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_u32ScriptZZ)); }
-       CVec_C2Tuple_u32ScriptZZ(LDKCVec_C2Tuple_u32ScriptZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_u32ScriptZZ)); }
-       operator LDKCVec_C2Tuple_u32ScriptZZ() && { LDKCVec_C2Tuple_u32ScriptZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_u32ScriptZZ)); return res; }
-       ~CVec_C2Tuple_u32ScriptZZ() { CVec_C2Tuple_u32ScriptZZ_free(self); }
-       CVec_C2Tuple_u32ScriptZZ& operator=(CVec_C2Tuple_u32ScriptZZ&& o) { CVec_C2Tuple_u32ScriptZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_u32ScriptZZ)); return *this; }
-       LDKCVec_C2Tuple_u32ScriptZZ* operator &() { return &self; }
-       LDKCVec_C2Tuple_u32ScriptZZ* operator ->() { return &self; }
-       const LDKCVec_C2Tuple_u32ScriptZZ* operator &() const { return &self; }
-       const LDKCVec_C2Tuple_u32ScriptZZ* operator ->() const { return &self; }
-};
 class CVec_MonitorEventZ {
 private:
        LDKCVec_MonitorEventZ self;
@@ -3922,6 +3937,21 @@ public:
        const LDKCVec_MonitorEventZ* operator &() const { return &self; }
        const LDKCVec_MonitorEventZ* operator ->() const { return &self; }
 };
+class CVec_C2Tuple_u32ScriptZZ {
+private:
+       LDKCVec_C2Tuple_u32ScriptZZ self;
+public:
+       CVec_C2Tuple_u32ScriptZZ(const CVec_C2Tuple_u32ScriptZZ&) = delete;
+       CVec_C2Tuple_u32ScriptZZ(CVec_C2Tuple_u32ScriptZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_u32ScriptZZ)); }
+       CVec_C2Tuple_u32ScriptZZ(LDKCVec_C2Tuple_u32ScriptZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_u32ScriptZZ)); }
+       operator LDKCVec_C2Tuple_u32ScriptZZ() && { LDKCVec_C2Tuple_u32ScriptZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_u32ScriptZZ)); return res; }
+       ~CVec_C2Tuple_u32ScriptZZ() { CVec_C2Tuple_u32ScriptZZ_free(self); }
+       CVec_C2Tuple_u32ScriptZZ& operator=(CVec_C2Tuple_u32ScriptZZ&& o) { CVec_C2Tuple_u32ScriptZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_u32ScriptZZ)); return *this; }
+       LDKCVec_C2Tuple_u32ScriptZZ* operator &() { return &self; }
+       LDKCVec_C2Tuple_u32ScriptZZ* operator ->() { return &self; }
+       const LDKCVec_C2Tuple_u32ScriptZZ* operator &() const { return &self; }
+       const LDKCVec_C2Tuple_u32ScriptZZ* operator ->() const { return &self; }
+};
 class CResult_NoneChannelMonitorUpdateErrZ {
 private:
        LDKCResult_NoneChannelMonitorUpdateErrZ self;
@@ -4087,21 +4117,6 @@ public:
        const LDKCResult_NodeFeaturesDecodeErrorZ* operator &() const { return &self; }
        const LDKCResult_NodeFeaturesDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_ReplyShortChannelIdsEndDecodeErrorZ {
-private:
-       LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ self;
-public:
-       CResult_ReplyShortChannelIdsEndDecodeErrorZ(const CResult_ReplyShortChannelIdsEndDecodeErrorZ&) = delete;
-       CResult_ReplyShortChannelIdsEndDecodeErrorZ(CResult_ReplyShortChannelIdsEndDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ReplyShortChannelIdsEndDecodeErrorZ)); }
-       CResult_ReplyShortChannelIdsEndDecodeErrorZ(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ)); }
-       operator LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ() && { LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ)); return res; }
-       ~CResult_ReplyShortChannelIdsEndDecodeErrorZ() { CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(self); }
-       CResult_ReplyShortChannelIdsEndDecodeErrorZ& operator=(CResult_ReplyShortChannelIdsEndDecodeErrorZ&& o) { CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ReplyShortChannelIdsEndDecodeErrorZ)); return *this; }
-       LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator &() { return &self; }
-       LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator ->() { return &self; }
-       const LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator &() const { return &self; }
-       const LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator ->() const { return &self; }
-};
 class CResult_InMemorySignerDecodeErrorZ {
 private:
        LDKCResult_InMemorySignerDecodeErrorZ self;
@@ -4117,6 +4132,21 @@ public:
        const LDKCResult_InMemorySignerDecodeErrorZ* operator &() const { return &self; }
        const LDKCResult_InMemorySignerDecodeErrorZ* operator ->() const { return &self; }
 };
+class CResult_PaymentSecretAPIErrorZ {
+private:
+       LDKCResult_PaymentSecretAPIErrorZ self;
+public:
+       CResult_PaymentSecretAPIErrorZ(const CResult_PaymentSecretAPIErrorZ&) = delete;
+       CResult_PaymentSecretAPIErrorZ(CResult_PaymentSecretAPIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentSecretAPIErrorZ)); }
+       CResult_PaymentSecretAPIErrorZ(LDKCResult_PaymentSecretAPIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentSecretAPIErrorZ)); }
+       operator LDKCResult_PaymentSecretAPIErrorZ() && { LDKCResult_PaymentSecretAPIErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentSecretAPIErrorZ)); return res; }
+       ~CResult_PaymentSecretAPIErrorZ() { CResult_PaymentSecretAPIErrorZ_free(self); }
+       CResult_PaymentSecretAPIErrorZ& operator=(CResult_PaymentSecretAPIErrorZ&& o) { CResult_PaymentSecretAPIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentSecretAPIErrorZ)); return *this; }
+       LDKCResult_PaymentSecretAPIErrorZ* operator &() { return &self; }
+       LDKCResult_PaymentSecretAPIErrorZ* operator ->() { return &self; }
+       const LDKCResult_PaymentSecretAPIErrorZ* operator &() const { return &self; }
+       const LDKCResult_PaymentSecretAPIErrorZ* operator ->() const { return &self; }
+};
 class C2Tuple_u32ScriptZ {
 private:
        LDKC2Tuple_u32ScriptZ self;
@@ -4147,35 +4177,35 @@ public:
        const LDKCResult_CResult_NetAddressu8ZDecodeErrorZ* operator &() const { return &self; }
        const LDKCResult_CResult_NetAddressu8ZDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_PaymentSecretAPIErrorZ {
+class CResult_ReplyShortChannelIdsEndDecodeErrorZ {
 private:
-       LDKCResult_PaymentSecretAPIErrorZ self;
+       LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ self;
 public:
-       CResult_PaymentSecretAPIErrorZ(const CResult_PaymentSecretAPIErrorZ&) = delete;
-       CResult_PaymentSecretAPIErrorZ(CResult_PaymentSecretAPIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentSecretAPIErrorZ)); }
-       CResult_PaymentSecretAPIErrorZ(LDKCResult_PaymentSecretAPIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentSecretAPIErrorZ)); }
-       operator LDKCResult_PaymentSecretAPIErrorZ() && { LDKCResult_PaymentSecretAPIErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentSecretAPIErrorZ)); return res; }
-       ~CResult_PaymentSecretAPIErrorZ() { CResult_PaymentSecretAPIErrorZ_free(self); }
-       CResult_PaymentSecretAPIErrorZ& operator=(CResult_PaymentSecretAPIErrorZ&& o) { CResult_PaymentSecretAPIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentSecretAPIErrorZ)); return *this; }
-       LDKCResult_PaymentSecretAPIErrorZ* operator &() { return &self; }
-       LDKCResult_PaymentSecretAPIErrorZ* operator ->() { return &self; }
-       const LDKCResult_PaymentSecretAPIErrorZ* operator &() const { return &self; }
-       const LDKCResult_PaymentSecretAPIErrorZ* operator ->() const { return &self; }
+       CResult_ReplyShortChannelIdsEndDecodeErrorZ(const CResult_ReplyShortChannelIdsEndDecodeErrorZ&) = delete;
+       CResult_ReplyShortChannelIdsEndDecodeErrorZ(CResult_ReplyShortChannelIdsEndDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ReplyShortChannelIdsEndDecodeErrorZ)); }
+       CResult_ReplyShortChannelIdsEndDecodeErrorZ(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ)); }
+       operator LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ() && { LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ)); return res; }
+       ~CResult_ReplyShortChannelIdsEndDecodeErrorZ() { CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(self); }
+       CResult_ReplyShortChannelIdsEndDecodeErrorZ& operator=(CResult_ReplyShortChannelIdsEndDecodeErrorZ&& o) { CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ReplyShortChannelIdsEndDecodeErrorZ)); return *this; }
+       LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator &() { return &self; }
+       LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator ->() { return &self; }
+       const LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator &() const { return &self; }
+       const LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ {
+class CResult_RouteDecodeErrorZ {
 private:
-       LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ self;
+       LDKCResult_RouteDecodeErrorZ self;
 public:
-       CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ(const CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ&) = delete;
-       CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ(CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ)); }
-       CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ)); }
-       operator LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ() && { LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ)); return res; }
-       ~CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ() { CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(self); }
-       CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ& operator=(CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ&& o) { CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ)); return *this; }
-       LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* operator &() { return &self; }
-       LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* operator ->() { return &self; }
-       const LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* operator &() const { return &self; }
-       const LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* operator ->() const { return &self; }
+       CResult_RouteDecodeErrorZ(const CResult_RouteDecodeErrorZ&) = delete;
+       CResult_RouteDecodeErrorZ(CResult_RouteDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteDecodeErrorZ)); }
+       CResult_RouteDecodeErrorZ(LDKCResult_RouteDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteDecodeErrorZ)); }
+       operator LDKCResult_RouteDecodeErrorZ() && { LDKCResult_RouteDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteDecodeErrorZ)); return res; }
+       ~CResult_RouteDecodeErrorZ() { CResult_RouteDecodeErrorZ_free(self); }
+       CResult_RouteDecodeErrorZ& operator=(CResult_RouteDecodeErrorZ&& o) { CResult_RouteDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteDecodeErrorZ)); return *this; }
+       LDKCResult_RouteDecodeErrorZ* operator &() { return &self; }
+       LDKCResult_RouteDecodeErrorZ* operator ->() { return &self; }
+       const LDKCResult_RouteDecodeErrorZ* operator &() const { return &self; }
+       const LDKCResult_RouteDecodeErrorZ* operator ->() const { return &self; }
 };
 class CResult_BuiltCommitmentTransactionDecodeErrorZ {
 private:
@@ -4192,20 +4222,35 @@ public:
        const LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
        const LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_RouteDecodeErrorZ {
+class CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ {
 private:
-       LDKCResult_RouteDecodeErrorZ self;
+       LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ self;
 public:
-       CResult_RouteDecodeErrorZ(const CResult_RouteDecodeErrorZ&) = delete;
-       CResult_RouteDecodeErrorZ(CResult_RouteDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteDecodeErrorZ)); }
-       CResult_RouteDecodeErrorZ(LDKCResult_RouteDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteDecodeErrorZ)); }
-       operator LDKCResult_RouteDecodeErrorZ() && { LDKCResult_RouteDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteDecodeErrorZ)); return res; }
-       ~CResult_RouteDecodeErrorZ() { CResult_RouteDecodeErrorZ_free(self); }
-       CResult_RouteDecodeErrorZ& operator=(CResult_RouteDecodeErrorZ&& o) { CResult_RouteDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteDecodeErrorZ)); return *this; }
-       LDKCResult_RouteDecodeErrorZ* operator &() { return &self; }
-       LDKCResult_RouteDecodeErrorZ* operator ->() { return &self; }
-       const LDKCResult_RouteDecodeErrorZ* operator &() const { return &self; }
-       const LDKCResult_RouteDecodeErrorZ* operator ->() const { return &self; }
+       CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ(const CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ&) = delete;
+       CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ(CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ)); }
+       CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ)); }
+       operator LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ() && { LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ)); return res; }
+       ~CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ() { CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(self); }
+       CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ& operator=(CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ&& o) { CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ)); return *this; }
+       LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* operator &() { return &self; }
+       LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* operator ->() { return &self; }
+       const LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* operator &() const { return &self; }
+       const LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* operator ->() const { return &self; }
+};
+class CVec_TxOutZ {
+private:
+       LDKCVec_TxOutZ self;
+public:
+       CVec_TxOutZ(const CVec_TxOutZ&) = delete;
+       CVec_TxOutZ(CVec_TxOutZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TxOutZ)); }
+       CVec_TxOutZ(LDKCVec_TxOutZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TxOutZ)); }
+       operator LDKCVec_TxOutZ() && { LDKCVec_TxOutZ res = self; memset(&self, 0, sizeof(LDKCVec_TxOutZ)); return res; }
+       ~CVec_TxOutZ() { CVec_TxOutZ_free(self); }
+       CVec_TxOutZ& operator=(CVec_TxOutZ&& o) { CVec_TxOutZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TxOutZ)); return *this; }
+       LDKCVec_TxOutZ* operator &() { return &self; }
+       LDKCVec_TxOutZ* operator ->() { return &self; }
+       const LDKCVec_TxOutZ* operator &() const { return &self; }
+       const LDKCVec_TxOutZ* operator ->() const { return &self; }
 };
 class CVec_UpdateFailHTLCZ {
 private:
@@ -4237,19 +4282,4 @@ public:
        const LDKCResult_FundingLockedDecodeErrorZ* operator &() const { return &self; }
        const LDKCResult_FundingLockedDecodeErrorZ* operator ->() const { return &self; }
 };
-class CVec_TxOutZ {
-private:
-       LDKCVec_TxOutZ self;
-public:
-       CVec_TxOutZ(const CVec_TxOutZ&) = delete;
-       CVec_TxOutZ(CVec_TxOutZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TxOutZ)); }
-       CVec_TxOutZ(LDKCVec_TxOutZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TxOutZ)); }
-       operator LDKCVec_TxOutZ() && { LDKCVec_TxOutZ res = self; memset(&self, 0, sizeof(LDKCVec_TxOutZ)); return res; }
-       ~CVec_TxOutZ() { CVec_TxOutZ_free(self); }
-       CVec_TxOutZ& operator=(CVec_TxOutZ&& o) { CVec_TxOutZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TxOutZ)); return *this; }
-       LDKCVec_TxOutZ* operator &() { return &self; }
-       LDKCVec_TxOutZ* operator ->() { return &self; }
-       const LDKCVec_TxOutZ* operator &() const { return &self; }
-       const LDKCVec_TxOutZ* operator ->() const { return &self; }
-};
 }
index 08052dbd2ac72523568cbe534df0f9e318233dac..0e48f5d593518ecc214d76176a09581520060ed4 100644 (file)
@@ -1,186 +1,4 @@
 #[repr(C)]
-/// The contents of CResult_ChannelConfigDecodeErrorZ
-pub union CResult_ChannelConfigDecodeErrorZPtr {
-       /// A pointer to the contents in the success state.
-       /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::util::config::ChannelConfig,
-       /// A pointer to the contents in the error state.
-       /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::lightning::ln::msgs::DecodeError,
-}
-#[repr(C)]
-/// A CResult_ChannelConfigDecodeErrorZ represents the result of a fallible operation,
-/// containing a crate::lightning::util::config::ChannelConfig on success and a crate::lightning::ln::msgs::DecodeError on failure.
-/// `result_ok` indicates the overall state, and the contents are provided via `contents`.
-pub struct CResult_ChannelConfigDecodeErrorZ {
-       /// The contents of this CResult_ChannelConfigDecodeErrorZ, accessible via either
-       /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_ChannelConfigDecodeErrorZPtr,
-       /// Whether this CResult_ChannelConfigDecodeErrorZ represents a success state.
-       pub result_ok: bool,
-}
-#[no_mangle]
-/// Creates a new CResult_ChannelConfigDecodeErrorZ in the success state.
-pub extern "C" fn CResult_ChannelConfigDecodeErrorZ_ok(o: crate::lightning::util::config::ChannelConfig) -> CResult_ChannelConfigDecodeErrorZ {
-       CResult_ChannelConfigDecodeErrorZ {
-               contents: CResult_ChannelConfigDecodeErrorZPtr {
-                       result: Box::into_raw(Box::new(o)),
-               },
-               result_ok: true,
-       }
-}
-#[no_mangle]
-/// Creates a new CResult_ChannelConfigDecodeErrorZ in the error state.
-pub extern "C" fn CResult_ChannelConfigDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_ChannelConfigDecodeErrorZ {
-       CResult_ChannelConfigDecodeErrorZ {
-               contents: CResult_ChannelConfigDecodeErrorZPtr {
-                       err: Box::into_raw(Box::new(e)),
-               },
-               result_ok: false,
-       }
-}
-#[no_mangle]
-/// Frees any resources used by the CResult_ChannelConfigDecodeErrorZ.
-pub extern "C" fn CResult_ChannelConfigDecodeErrorZ_free(_res: CResult_ChannelConfigDecodeErrorZ) { }
-impl Drop for CResult_ChannelConfigDecodeErrorZ {
-       fn drop(&mut self) {
-               if self.result_ok {
-                       if unsafe { !(self.contents.result as *mut ()).is_null() } {
-                               let _ = unsafe { Box::from_raw(self.contents.result) };
-                       }
-               } else {
-                       if unsafe { !(self.contents.err as *mut ()).is_null() } {
-                               let _ = unsafe { Box::from_raw(self.contents.err) };
-                       }
-               }
-       }
-}
-impl From<crate::c_types::CResultTempl<crate::lightning::util::config::ChannelConfig, crate::lightning::ln::msgs::DecodeError>> for CResult_ChannelConfigDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::util::config::ChannelConfig, crate::lightning::ln::msgs::DecodeError>) -> Self {
-               let contents = if o.result_ok {
-                       let result = unsafe { o.contents.result };
-                       unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_ChannelConfigDecodeErrorZPtr { result }
-               } else {
-                       let err = unsafe { o.contents.err };
-                       unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_ChannelConfigDecodeErrorZPtr { err }
-               };
-               Self {
-                       contents,
-                       result_ok: o.result_ok,
-               }
-       }
-}
-impl Clone for CResult_ChannelConfigDecodeErrorZ {
-       fn clone(&self) -> Self {
-               if self.result_ok {
-                       Self { result_ok: true, contents: CResult_ChannelConfigDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::util::config::ChannelConfig>::clone(unsafe { &*self.contents.result })))
-                       } }
-               } else {
-                       Self { result_ok: false, contents: CResult_ChannelConfigDecodeErrorZPtr {
-                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
-                       } }
-               }
-       }
-}
-#[no_mangle]
-/// Creates a new CResult_ChannelConfigDecodeErrorZ which has the same data as `orig`
-/// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_ChannelConfigDecodeErrorZ_clone(orig: &CResult_ChannelConfigDecodeErrorZ) -> CResult_ChannelConfigDecodeErrorZ { orig.clone() }
-#[repr(C)]
-/// The contents of CResult_OutPointDecodeErrorZ
-pub union CResult_OutPointDecodeErrorZPtr {
-       /// A pointer to the contents in the success state.
-       /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::chain::transaction::OutPoint,
-       /// A pointer to the contents in the error state.
-       /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::lightning::ln::msgs::DecodeError,
-}
-#[repr(C)]
-/// A CResult_OutPointDecodeErrorZ represents the result of a fallible operation,
-/// containing a crate::lightning::chain::transaction::OutPoint on success and a crate::lightning::ln::msgs::DecodeError on failure.
-/// `result_ok` indicates the overall state, and the contents are provided via `contents`.
-pub struct CResult_OutPointDecodeErrorZ {
-       /// The contents of this CResult_OutPointDecodeErrorZ, accessible via either
-       /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_OutPointDecodeErrorZPtr,
-       /// Whether this CResult_OutPointDecodeErrorZ represents a success state.
-       pub result_ok: bool,
-}
-#[no_mangle]
-/// Creates a new CResult_OutPointDecodeErrorZ in the success state.
-pub extern "C" fn CResult_OutPointDecodeErrorZ_ok(o: crate::lightning::chain::transaction::OutPoint) -> CResult_OutPointDecodeErrorZ {
-       CResult_OutPointDecodeErrorZ {
-               contents: CResult_OutPointDecodeErrorZPtr {
-                       result: Box::into_raw(Box::new(o)),
-               },
-               result_ok: true,
-       }
-}
-#[no_mangle]
-/// Creates a new CResult_OutPointDecodeErrorZ in the error state.
-pub extern "C" fn CResult_OutPointDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_OutPointDecodeErrorZ {
-       CResult_OutPointDecodeErrorZ {
-               contents: CResult_OutPointDecodeErrorZPtr {
-                       err: Box::into_raw(Box::new(e)),
-               },
-               result_ok: false,
-       }
-}
-#[no_mangle]
-/// Frees any resources used by the CResult_OutPointDecodeErrorZ.
-pub extern "C" fn CResult_OutPointDecodeErrorZ_free(_res: CResult_OutPointDecodeErrorZ) { }
-impl Drop for CResult_OutPointDecodeErrorZ {
-       fn drop(&mut self) {
-               if self.result_ok {
-                       if unsafe { !(self.contents.result as *mut ()).is_null() } {
-                               let _ = unsafe { Box::from_raw(self.contents.result) };
-                       }
-               } else {
-                       if unsafe { !(self.contents.err as *mut ()).is_null() } {
-                               let _ = unsafe { Box::from_raw(self.contents.err) };
-                       }
-               }
-       }
-}
-impl From<crate::c_types::CResultTempl<crate::lightning::chain::transaction::OutPoint, crate::lightning::ln::msgs::DecodeError>> for CResult_OutPointDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::chain::transaction::OutPoint, crate::lightning::ln::msgs::DecodeError>) -> Self {
-               let contents = if o.result_ok {
-                       let result = unsafe { o.contents.result };
-                       unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_OutPointDecodeErrorZPtr { result }
-               } else {
-                       let err = unsafe { o.contents.err };
-                       unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_OutPointDecodeErrorZPtr { err }
-               };
-               Self {
-                       contents,
-                       result_ok: o.result_ok,
-               }
-       }
-}
-impl Clone for CResult_OutPointDecodeErrorZ {
-       fn clone(&self) -> Self {
-               if self.result_ok {
-                       Self { result_ok: true, contents: CResult_OutPointDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::chain::transaction::OutPoint>::clone(unsafe { &*self.contents.result })))
-                       } }
-               } else {
-                       Self { result_ok: false, contents: CResult_OutPointDecodeErrorZPtr {
-                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
-                       } }
-               }
-       }
-}
-#[no_mangle]
-/// Creates a new CResult_OutPointDecodeErrorZ which has the same data as `orig`
-/// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_OutPointDecodeErrorZ_clone(orig: &CResult_OutPointDecodeErrorZ) -> CResult_OutPointDecodeErrorZ { orig.clone() }
-#[repr(C)]
 /// The contents of CResult_SecretKeyErrorZ
 pub union CResult_SecretKeyErrorZPtr {
        /// A pointer to the contents in the success state.
@@ -328,6 +146,23 @@ impl From<crate::c_types::CResultTempl<crate::c_types::PublicKey, crate::c_types
                }
        }
 }
+impl Clone for CResult_PublicKeyErrorZ {
+       fn clone(&self) -> Self {
+               if self.result_ok {
+                       Self { result_ok: true, contents: CResult_PublicKeyErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::c_types::PublicKey>::clone(unsafe { &*self.contents.result })))
+                       } }
+               } else {
+                       Self { result_ok: false, contents: CResult_PublicKeyErrorZPtr {
+                               err: Box::into_raw(Box::new(<crate::c_types::Secp256k1Error>::clone(unsafe { &*self.contents.err })))
+                       } }
+               }
+       }
+}
+#[no_mangle]
+/// Creates a new CResult_PublicKeyErrorZ which has the same data as `orig`
+/// but with all dynamically-allocated buffers duplicated in new buffers.
+pub extern "C" fn CResult_PublicKeyErrorZ_clone(orig: &CResult_PublicKeyErrorZ) -> CResult_PublicKeyErrorZ { orig.clone() }
 #[repr(C)]
 /// The contents of CResult_TxCreationKeysDecodeErrorZ
 pub union CResult_TxCreationKeysDecodeErrorZPtr {
@@ -584,6 +419,23 @@ impl From<crate::c_types::CResultTempl<crate::lightning::ln::chan_utils::TxCreat
                }
        }
 }
+impl Clone for CResult_TxCreationKeysErrorZ {
+       fn clone(&self) -> Self {
+               if self.result_ok {
+                       Self { result_ok: true, contents: CResult_TxCreationKeysErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::ln::chan_utils::TxCreationKeys>::clone(unsafe { &*self.contents.result })))
+                       } }
+               } else {
+                       Self { result_ok: false, contents: CResult_TxCreationKeysErrorZPtr {
+                               err: Box::into_raw(Box::new(<crate::c_types::Secp256k1Error>::clone(unsafe { &*self.contents.err })))
+                       } }
+               }
+       }
+}
+#[no_mangle]
+/// Creates a new CResult_TxCreationKeysErrorZ which has the same data as `orig`
+/// but with all dynamically-allocated buffers duplicated in new buffers.
+pub extern "C" fn CResult_TxCreationKeysErrorZ_clone(orig: &CResult_TxCreationKeysErrorZ) -> CResult_TxCreationKeysErrorZ { orig.clone() }
 #[repr(C)]
 #[derive(Clone)]
 /// An enum which can either contain a u32 or not
@@ -1368,68 +1220,68 @@ impl Clone for CResult_CVec_SignatureZNoneZ {
 /// but with all dynamically-allocated buffers duplicated in new buffers.
 pub extern "C" fn CResult_CVec_SignatureZNoneZ_clone(orig: &CResult_CVec_SignatureZNoneZ) -> CResult_CVec_SignatureZNoneZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_SiPrefixNoneZ
-pub union CResult_SiPrefixNoneZPtr {
-       /// A pointer to the contents in the success state.
-       /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning_invoice::SiPrefix,
-       /// Note that this value is always NULL, as there are no contents in the Err variant
-       pub err: *mut std::ffi::c_void,
+/// The contents of CResult_NoneErrorZ
+pub union CResult_NoneErrorZPtr {
+       /// Note that this value is always NULL, as there are no contents in the OK variant
+       pub result: *mut std::ffi::c_void,
+       /// A pointer to the contents in the error state.
+       /// Reading from this pointer when `result_ok` is set is undefined.
+       pub err: *mut crate::c_types::IOError,
 }
 #[repr(C)]
-/// A CResult_SiPrefixNoneZ represents the result of a fallible operation,
-/// containing a crate::lightning_invoice::SiPrefix on success and a () on failure.
+/// 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`.
-pub struct CResult_SiPrefixNoneZ {
-       /// The contents of this CResult_SiPrefixNoneZ, accessible via either
+pub struct CResult_NoneErrorZ {
+       /// The contents of this CResult_NoneErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_SiPrefixNoneZPtr,
-       /// Whether this CResult_SiPrefixNoneZ represents a success state.
+       pub contents: CResult_NoneErrorZPtr,
+       /// Whether this CResult_NoneErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_SiPrefixNoneZ in the success state.
-pub extern "C" fn CResult_SiPrefixNoneZ_ok(o: crate::lightning_invoice::SiPrefix) -> CResult_SiPrefixNoneZ {
-       CResult_SiPrefixNoneZ {
-               contents: CResult_SiPrefixNoneZPtr {
-                       result: Box::into_raw(Box::new(o)),
+/// Creates a new CResult_NoneErrorZ in the success state.
+pub extern "C" fn CResult_NoneErrorZ_ok() -> CResult_NoneErrorZ {
+       CResult_NoneErrorZ {
+               contents: CResult_NoneErrorZPtr {
+                       result: std::ptr::null_mut(),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_SiPrefixNoneZ in the error state.
-pub extern "C" fn CResult_SiPrefixNoneZ_err() -> CResult_SiPrefixNoneZ {
-       CResult_SiPrefixNoneZ {
-               contents: CResult_SiPrefixNoneZPtr {
-                       err: std::ptr::null_mut(),
+/// Creates a new CResult_NoneErrorZ in the error state.
+pub extern "C" fn CResult_NoneErrorZ_err(e: crate::c_types::IOError) -> CResult_NoneErrorZ {
+       CResult_NoneErrorZ {
+               contents: CResult_NoneErrorZPtr {
+                       err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_SiPrefixNoneZ.
-pub extern "C" fn CResult_SiPrefixNoneZ_free(_res: CResult_SiPrefixNoneZ) { }
-impl Drop for CResult_SiPrefixNoneZ {
+/// Frees any resources used by the CResult_NoneErrorZ.
+pub extern "C" fn CResult_NoneErrorZ_free(_res: CResult_NoneErrorZ) { }
+impl Drop for CResult_NoneErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
-                       if unsafe { !(self.contents.result as *mut ()).is_null() } {
-                               let _ = unsafe { Box::from_raw(self.contents.result) };
-                       }
                } else {
+                       if unsafe { !(self.contents.err as *mut ()).is_null() } {
+                               let _ = unsafe { Box::from_raw(self.contents.err) };
+                       }
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning_invoice::SiPrefix, ()>> for CResult_SiPrefixNoneZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning_invoice::SiPrefix, ()>) -> Self {
+impl From<crate::c_types::CResultTempl<(), crate::c_types::IOError>> for CResult_NoneErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<(), crate::c_types::IOError>) -> Self {
                let contents = if o.result_ok {
-                       let result = unsafe { o.contents.result };
-                       unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_SiPrefixNoneZPtr { result }
+                       let _ = unsafe { Box::from_raw(o.contents.result) };
+                       o.contents.result = std::ptr::null_mut();
+                       CResult_NoneErrorZPtr { result: std::ptr::null_mut() }
                } else {
-                       let _ = unsafe { Box::from_raw(o.contents.err) };
-                       o.contents.err = std::ptr::null_mut();
-                       CResult_SiPrefixNoneZPtr { err: std::ptr::null_mut() }
+                       let err = unsafe { o.contents.err };
+                       unsafe { o.contents.err = std::ptr::null_mut(); }
+                       CResult_NoneErrorZPtr { err }
                };
                Self {
                        contents,
@@ -1437,86 +1289,90 @@ impl From<crate::c_types::CResultTempl<crate::lightning_invoice::SiPrefix, ()>>
                }
        }
 }
-impl Clone for CResult_SiPrefixNoneZ {
+impl Clone for CResult_NoneErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_SiPrefixNoneZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning_invoice::SiPrefix>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_NoneErrorZPtr {
+                               result: std::ptr::null_mut()
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_SiPrefixNoneZPtr {
-                               err: std::ptr::null_mut()
+                       Self { result_ok: false, contents: CResult_NoneErrorZPtr {
+                               err: Box::into_raw(Box::new(<crate::c_types::IOError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_SiPrefixNoneZ which has the same data as `orig`
+/// Creates a new CResult_NoneErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_SiPrefixNoneZ_clone(orig: &CResult_SiPrefixNoneZ) -> CResult_SiPrefixNoneZ { orig.clone() }
+pub extern "C" fn CResult_NoneErrorZ_clone(orig: &CResult_NoneErrorZ) -> CResult_NoneErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_InvoiceNoneZ
-pub union CResult_InvoiceNoneZPtr {
+/// The contents of CResult_RouteHopDecodeErrorZ
+pub union CResult_RouteHopDecodeErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning_invoice::Invoice,
-       /// Note that this value is always NULL, as there are no contents in the Err variant
-       pub err: *mut std::ffi::c_void,
+       pub result: *mut crate::lightning::routing::router::RouteHop,
+       /// A pointer to the contents in the error state.
+       /// Reading from this pointer when `result_ok` is set is undefined.
+       pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// A CResult_InvoiceNoneZ represents the result of a fallible operation,
-/// containing a crate::lightning_invoice::Invoice on success and a () on failure.
+/// A CResult_RouteHopDecodeErrorZ represents the result of a fallible operation,
+/// containing a crate::lightning::routing::router::RouteHop on success and a crate::lightning::ln::msgs::DecodeError on failure.
 /// `result_ok` indicates the overall state, and the contents are provided via `contents`.
-pub struct CResult_InvoiceNoneZ {
-       /// The contents of this CResult_InvoiceNoneZ, accessible via either
+pub struct CResult_RouteHopDecodeErrorZ {
+       /// The contents of this CResult_RouteHopDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_InvoiceNoneZPtr,
-       /// Whether this CResult_InvoiceNoneZ represents a success state.
+       pub contents: CResult_RouteHopDecodeErrorZPtr,
+       /// Whether this CResult_RouteHopDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_InvoiceNoneZ in the success state.
-pub extern "C" fn CResult_InvoiceNoneZ_ok(o: crate::lightning_invoice::Invoice) -> CResult_InvoiceNoneZ {
-       CResult_InvoiceNoneZ {
-               contents: CResult_InvoiceNoneZPtr {
+/// Creates a new CResult_RouteHopDecodeErrorZ in the success state.
+pub extern "C" fn CResult_RouteHopDecodeErrorZ_ok(o: crate::lightning::routing::router::RouteHop) -> CResult_RouteHopDecodeErrorZ {
+       CResult_RouteHopDecodeErrorZ {
+               contents: CResult_RouteHopDecodeErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_InvoiceNoneZ in the error state.
-pub extern "C" fn CResult_InvoiceNoneZ_err() -> CResult_InvoiceNoneZ {
-       CResult_InvoiceNoneZ {
-               contents: CResult_InvoiceNoneZPtr {
-                       err: std::ptr::null_mut(),
+/// Creates a new CResult_RouteHopDecodeErrorZ in the error state.
+pub extern "C" fn CResult_RouteHopDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_RouteHopDecodeErrorZ {
+       CResult_RouteHopDecodeErrorZ {
+               contents: CResult_RouteHopDecodeErrorZPtr {
+                       err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_InvoiceNoneZ.
-pub extern "C" fn CResult_InvoiceNoneZ_free(_res: CResult_InvoiceNoneZ) { }
-impl Drop for CResult_InvoiceNoneZ {
+/// Frees any resources used by the CResult_RouteHopDecodeErrorZ.
+pub extern "C" fn CResult_RouteHopDecodeErrorZ_free(_res: CResult_RouteHopDecodeErrorZ) { }
+impl Drop for CResult_RouteHopDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
                                let _ = unsafe { Box::from_raw(self.contents.result) };
                        }
                } else {
+                       if unsafe { !(self.contents.err as *mut ()).is_null() } {
+                               let _ = unsafe { Box::from_raw(self.contents.err) };
+                       }
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning_invoice::Invoice, ()>> for CResult_InvoiceNoneZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning_invoice::Invoice, ()>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::routing::router::RouteHop, crate::lightning::ln::msgs::DecodeError>> for CResult_RouteHopDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::routing::router::RouteHop, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_InvoiceNoneZPtr { result }
+                       CResult_RouteHopDecodeErrorZPtr { result }
                } else {
-                       let _ = unsafe { Box::from_raw(o.contents.err) };
-                       o.contents.err = std::ptr::null_mut();
-                       CResult_InvoiceNoneZPtr { err: std::ptr::null_mut() }
+                       let err = unsafe { o.contents.err };
+                       unsafe { o.contents.err = std::ptr::null_mut(); }
+                       CResult_RouteHopDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -1524,134 +1380,93 @@ impl From<crate::c_types::CResultTempl<crate::lightning_invoice::Invoice, ()>> f
                }
        }
 }
-impl Clone for CResult_InvoiceNoneZ {
+impl Clone for CResult_RouteHopDecodeErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_InvoiceNoneZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning_invoice::Invoice>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_RouteHopDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::routing::router::RouteHop>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_InvoiceNoneZPtr {
-                               err: std::ptr::null_mut()
+                       Self { result_ok: false, contents: CResult_RouteHopDecodeErrorZPtr {
+                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_InvoiceNoneZ which has the same data as `orig`
+/// Creates a new CResult_RouteHopDecodeErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_InvoiceNoneZ_clone(orig: &CResult_InvoiceNoneZ) -> CResult_InvoiceNoneZ { orig.clone() }
-#[repr(C)]
-/// The contents of CResult_SignedRawInvoiceNoneZ
-pub union CResult_SignedRawInvoiceNoneZPtr {
-       /// A pointer to the contents in the success state.
-       /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning_invoice::SignedRawInvoice,
-       /// Note that this value is always NULL, as there are no contents in the Err variant
-       pub err: *mut std::ffi::c_void,
-}
+pub extern "C" fn CResult_RouteHopDecodeErrorZ_clone(orig: &CResult_RouteHopDecodeErrorZ) -> CResult_RouteHopDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// A CResult_SignedRawInvoiceNoneZ represents the result of a fallible operation,
-/// containing a crate::lightning_invoice::SignedRawInvoice on success and a () on failure.
-/// `result_ok` indicates the overall state, and the contents are provided via `contents`.
-pub struct CResult_SignedRawInvoiceNoneZ {
-       /// The contents of this CResult_SignedRawInvoiceNoneZ, accessible via either
-       /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_SignedRawInvoiceNoneZPtr,
-       /// Whether this CResult_SignedRawInvoiceNoneZ represents a success state.
-       pub result_ok: bool,
+/// A dynamically-allocated array of crate::lightning::routing::router::RouteHops of arbitrary size.
+/// This corresponds to std::vector in C++
+pub struct CVec_RouteHopZ {
+       /// The elements in the array.
+       /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+       pub data: *mut crate::lightning::routing::router::RouteHop,
+       /// The number of elements pointed to by `data`.
+       pub datalen: usize
 }
-#[no_mangle]
-/// Creates a new CResult_SignedRawInvoiceNoneZ in the success state.
-pub extern "C" fn CResult_SignedRawInvoiceNoneZ_ok(o: crate::lightning_invoice::SignedRawInvoice) -> CResult_SignedRawInvoiceNoneZ {
-       CResult_SignedRawInvoiceNoneZ {
-               contents: CResult_SignedRawInvoiceNoneZPtr {
-                       result: Box::into_raw(Box::new(o)),
-               },
-               result_ok: true,
+impl CVec_RouteHopZ {
+       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::lightning::routing::router::RouteHop> {
+               if self.datalen == 0 { return Vec::new(); }
+               let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
+               self.data = std::ptr::null_mut();
+               self.datalen = 0;
+               ret
+       }
+       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::lightning::routing::router::RouteHop] {
+               unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
        }
 }
-#[no_mangle]
-/// Creates a new CResult_SignedRawInvoiceNoneZ in the error state.
-pub extern "C" fn CResult_SignedRawInvoiceNoneZ_err() -> CResult_SignedRawInvoiceNoneZ {
-       CResult_SignedRawInvoiceNoneZ {
-               contents: CResult_SignedRawInvoiceNoneZPtr {
-                       err: std::ptr::null_mut(),
-               },
-               result_ok: false,
+impl From<Vec<crate::lightning::routing::router::RouteHop>> for CVec_RouteHopZ {
+       fn from(v: Vec<crate::lightning::routing::router::RouteHop>) -> Self {
+               let datalen = v.len();
+               let data = Box::into_raw(v.into_boxed_slice());
+               Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_SignedRawInvoiceNoneZ.
-pub extern "C" fn CResult_SignedRawInvoiceNoneZ_free(_res: CResult_SignedRawInvoiceNoneZ) { }
-impl Drop for CResult_SignedRawInvoiceNoneZ {
+/// Frees the buffer pointed to by `data` if `datalen` is non-0.
+pub extern "C" fn CVec_RouteHopZ_free(_res: CVec_RouteHopZ) { }
+impl Drop for CVec_RouteHopZ {
        fn drop(&mut self) {
-               if self.result_ok {
-                       if unsafe { !(self.contents.result as *mut ()).is_null() } {
-                               let _ = unsafe { Box::from_raw(self.contents.result) };
-                       }
-               } else {
-               }
-       }
-}
-impl From<crate::c_types::CResultTempl<crate::lightning_invoice::SignedRawInvoice, ()>> for CResult_SignedRawInvoiceNoneZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning_invoice::SignedRawInvoice, ()>) -> Self {
-               let contents = if o.result_ok {
-                       let result = unsafe { o.contents.result };
-                       unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_SignedRawInvoiceNoneZPtr { result }
-               } else {
-                       let _ = unsafe { Box::from_raw(o.contents.err) };
-                       o.contents.err = std::ptr::null_mut();
-                       CResult_SignedRawInvoiceNoneZPtr { err: std::ptr::null_mut() }
-               };
-               Self {
-                       contents,
-                       result_ok: o.result_ok,
-               }
+               if self.datalen == 0 { return; }
+               unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
        }
 }
-impl Clone for CResult_SignedRawInvoiceNoneZ {
+impl Clone for CVec_RouteHopZ {
        fn clone(&self) -> Self {
-               if self.result_ok {
-                       Self { result_ok: true, contents: CResult_SignedRawInvoiceNoneZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning_invoice::SignedRawInvoice>::clone(unsafe { &*self.contents.result })))
-                       } }
-               } else {
-                       Self { result_ok: false, contents: CResult_SignedRawInvoiceNoneZPtr {
-                               err: std::ptr::null_mut()
-                       } }
-               }
+               let mut res = Vec::new();
+               if self.datalen == 0 { return Self::from(res); }
+               res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
+               Self::from(res)
        }
 }
-#[no_mangle]
-/// Creates a new CResult_SignedRawInvoiceNoneZ which has the same data as `orig`
-/// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_SignedRawInvoiceNoneZ_clone(orig: &CResult_SignedRawInvoiceNoneZ) -> CResult_SignedRawInvoiceNoneZ { orig.clone() }
 #[repr(C)]
-/// A dynamically-allocated array of u8s of arbitrary size.
+/// A dynamically-allocated array of crate::c_types::derived::CVec_RouteHopZs of arbitrary size.
 /// This corresponds to std::vector in C++
-pub struct CVec_u8Z {
+pub struct CVec_CVec_RouteHopZZ {
        /// The elements in the array.
        /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
-       pub data: *mut u8,
+       pub data: *mut crate::c_types::derived::CVec_RouteHopZ,
        /// The number of elements pointed to by `data`.
        pub datalen: usize
 }
-impl CVec_u8Z {
-       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<u8> {
+impl CVec_CVec_RouteHopZZ {
+       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::c_types::derived::CVec_RouteHopZ> {
                if self.datalen == 0 { return Vec::new(); }
                let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
                self.data = std::ptr::null_mut();
                self.datalen = 0;
                ret
        }
-       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[u8] {
+       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::c_types::derived::CVec_RouteHopZ] {
                unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
        }
 }
-impl From<Vec<u8>> for CVec_u8Z {
-       fn from(v: Vec<u8>) -> Self {
+impl From<Vec<crate::c_types::derived::CVec_RouteHopZ>> for CVec_CVec_RouteHopZZ {
+       fn from(v: Vec<crate::c_types::derived::CVec_RouteHopZ>) -> Self {
                let datalen = v.len();
                let data = Box::into_raw(v.into_boxed_slice());
                Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
@@ -1659,14 +1474,14 @@ impl From<Vec<u8>> for CVec_u8Z {
 }
 #[no_mangle]
 /// Frees the buffer pointed to by `data` if `datalen` is non-0.
-pub extern "C" fn CVec_u8Z_free(_res: CVec_u8Z) { }
-impl Drop for CVec_u8Z {
+pub extern "C" fn CVec_CVec_RouteHopZZ_free(_res: CVec_CVec_RouteHopZZ) { }
+impl Drop for CVec_CVec_RouteHopZZ {
        fn drop(&mut self) {
                if self.datalen == 0 { return; }
                unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
        }
 }
-impl Clone for CVec_u8Z {
+impl Clone for CVec_CVec_RouteHopZZ {
        fn clone(&self) -> Self {
                let mut res = Vec::new();
                if self.datalen == 0 { return Self::from(res); }
@@ -1675,83 +1490,50 @@ impl Clone for CVec_u8Z {
        }
 }
 #[repr(C)]
-/// A tuple of 3 elements. See the individual fields for the types contained.
-pub struct C3Tuple_RawInvoice_u832InvoiceSignatureZ {
-       /// The element at position 0
-       pub a: crate::lightning_invoice::RawInvoice,
-       /// The element at position 1
-       pub b: crate::c_types::ThirtyTwoBytes,
-       /// The element at position 2
-       pub c: crate::lightning_invoice::InvoiceSignature,
-}
-impl From<(crate::lightning_invoice::RawInvoice, crate::c_types::ThirtyTwoBytes, crate::lightning_invoice::InvoiceSignature)> for C3Tuple_RawInvoice_u832InvoiceSignatureZ {
-       fn from (tup: (crate::lightning_invoice::RawInvoice, crate::c_types::ThirtyTwoBytes, crate::lightning_invoice::InvoiceSignature)) -> Self {
-               Self {
-                       a: tup.0,
-                       b: tup.1,
-                       c: tup.2,
-               }
-       }
-}
-impl C3Tuple_RawInvoice_u832InvoiceSignatureZ {
-       #[allow(unused)] pub(crate) fn to_rust(mut self) -> (crate::lightning_invoice::RawInvoice, crate::c_types::ThirtyTwoBytes, crate::lightning_invoice::InvoiceSignature) {
-               (self.a, self.b, self.c)
-       }
-}
-/// Creates a new C3Tuple_RawInvoice_u832InvoiceSignatureZ from the contained elements.
-#[no_mangle]
-pub extern "C" fn C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a: crate::lightning_invoice::RawInvoice, b: crate::c_types::ThirtyTwoBytes, c: crate::lightning_invoice::InvoiceSignature) -> C3Tuple_RawInvoice_u832InvoiceSignatureZ {
-       C3Tuple_RawInvoice_u832InvoiceSignatureZ { a, b, c, }
-}
-
-#[no_mangle]
-/// Frees any resources used by the C3Tuple_RawInvoice_u832InvoiceSignatureZ.
-pub extern "C" fn C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(_res: C3Tuple_RawInvoice_u832InvoiceSignatureZ) { }
-#[repr(C)]
-/// The contents of CResult_PayeePubKeyErrorZ
-pub union CResult_PayeePubKeyErrorZPtr {
-       /// A pointer to the contents in the success state.
-       /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning_invoice::PayeePubKey,
-       /// A pointer to the contents in the error state.
-       /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::c_types::Secp256k1Error,
+/// The contents of CResult_RouteDecodeErrorZ
+pub union CResult_RouteDecodeErrorZPtr {
+       /// A pointer to the contents in the success state.
+       /// Reading from this pointer when `result_ok` is not set is undefined.
+       pub result: *mut crate::lightning::routing::router::Route,
+       /// A pointer to the contents in the error state.
+       /// Reading from this pointer when `result_ok` is set is undefined.
+       pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// 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.
+/// 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`.
-pub struct CResult_PayeePubKeyErrorZ {
-       /// The contents of this CResult_PayeePubKeyErrorZ, accessible via either
+pub struct CResult_RouteDecodeErrorZ {
+       /// The contents of this CResult_RouteDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_PayeePubKeyErrorZPtr,
-       /// Whether this CResult_PayeePubKeyErrorZ represents a success state.
+       pub contents: CResult_RouteDecodeErrorZPtr,
+       /// Whether this CResult_RouteDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_PayeePubKeyErrorZ in the success state.
-pub extern "C" fn CResult_PayeePubKeyErrorZ_ok(o: crate::lightning_invoice::PayeePubKey) -> CResult_PayeePubKeyErrorZ {
-       CResult_PayeePubKeyErrorZ {
-               contents: CResult_PayeePubKeyErrorZPtr {
+/// Creates a new CResult_RouteDecodeErrorZ in the success state.
+pub extern "C" fn CResult_RouteDecodeErrorZ_ok(o: crate::lightning::routing::router::Route) -> CResult_RouteDecodeErrorZ {
+       CResult_RouteDecodeErrorZ {
+               contents: CResult_RouteDecodeErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_PayeePubKeyErrorZ in the error state.
-pub extern "C" fn CResult_PayeePubKeyErrorZ_err(e: crate::c_types::Secp256k1Error) -> CResult_PayeePubKeyErrorZ {
-       CResult_PayeePubKeyErrorZ {
-               contents: CResult_PayeePubKeyErrorZPtr {
+/// Creates a new CResult_RouteDecodeErrorZ in the error state.
+pub extern "C" fn CResult_RouteDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_RouteDecodeErrorZ {
+       CResult_RouteDecodeErrorZ {
+               contents: CResult_RouteDecodeErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_PayeePubKeyErrorZ.
-pub extern "C" fn CResult_PayeePubKeyErrorZ_free(_res: CResult_PayeePubKeyErrorZ) { }
-impl Drop for CResult_PayeePubKeyErrorZ {
+/// Frees any resources used by the CResult_RouteDecodeErrorZ.
+pub extern "C" fn CResult_RouteDecodeErrorZ_free(_res: CResult_RouteDecodeErrorZ) { }
+impl Drop for CResult_RouteDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -1764,16 +1546,16 @@ impl Drop for CResult_PayeePubKeyErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning_invoice::PayeePubKey, crate::c_types::Secp256k1Error>> for CResult_PayeePubKeyErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning_invoice::PayeePubKey, crate::c_types::Secp256k1Error>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::routing::router::Route, crate::lightning::ln::msgs::DecodeError>> for CResult_RouteDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::routing::router::Route, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_PayeePubKeyErrorZPtr { result }
+                       CResult_RouteDecodeErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_PayeePubKeyErrorZPtr { err }
+                       CResult_RouteDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -1781,30 +1563,81 @@ impl From<crate::c_types::CResultTempl<crate::lightning_invoice::PayeePubKey, cr
                }
        }
 }
+impl Clone for CResult_RouteDecodeErrorZ {
+       fn clone(&self) -> Self {
+               if self.result_ok {
+                       Self { result_ok: true, contents: CResult_RouteDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::routing::router::Route>::clone(unsafe { &*self.contents.result })))
+                       } }
+               } else {
+                       Self { result_ok: false, contents: CResult_RouteDecodeErrorZPtr {
+                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
+                       } }
+               }
+       }
+}
+#[no_mangle]
+/// Creates a new CResult_RouteDecodeErrorZ which has the same data as `orig`
+/// but with all dynamically-allocated buffers duplicated in new buffers.
+pub extern "C" fn CResult_RouteDecodeErrorZ_clone(orig: &CResult_RouteDecodeErrorZ) -> CResult_RouteDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// A dynamically-allocated array of crate::lightning_invoice::RouteHints of arbitrary size.
+#[derive(Clone)]
+/// An enum which can either contain a u64 or not
+pub enum COption_u64Z {
+       /// When we're in this state, this COption_u64Z contains a u64
+       Some(u64),
+       /// When we're in this state, this COption_u64Z contains nothing
+       None
+}
+impl COption_u64Z {
+       #[allow(unused)] pub(crate) fn is_some(&self) -> bool {
+               if let Self::Some(_) = self { true } else { false }
+       }
+       #[allow(unused)] pub(crate) fn take(mut self) -> u64 {
+               if let Self::Some(v) = self { v } else { unreachable!() }
+       }
+}
+#[no_mangle]
+/// Constructs a new COption_u64Z containing a u64
+pub extern "C" fn COption_u64Z_some(o: u64) -> COption_u64Z {
+       COption_u64Z::Some(o)
+}
+#[no_mangle]
+/// Constructs a new COption_u64Z containing nothing
+pub extern "C" fn COption_u64Z_none() -> COption_u64Z {
+       COption_u64Z::None
+}
+#[no_mangle]
+/// Frees any resources associated with the u64, if we are in the Some state
+pub extern "C" fn COption_u64Z_free(_res: COption_u64Z) { }
+#[no_mangle]
+/// Creates a new COption_u64Z which has the same data as `orig`
+/// but with all dynamically-allocated buffers duplicated in new buffers.
+pub extern "C" fn COption_u64Z_clone(orig: &COption_u64Z) -> COption_u64Z { orig.clone() }
+#[repr(C)]
+/// A dynamically-allocated array of crate::lightning::ln::channelmanager::ChannelDetailss of arbitrary size.
 /// This corresponds to std::vector in C++
-pub struct CVec_RouteHintZ {
+pub struct CVec_ChannelDetailsZ {
        /// The elements in the array.
        /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
-       pub data: *mut crate::lightning_invoice::RouteHint,
+       pub data: *mut crate::lightning::ln::channelmanager::ChannelDetails,
        /// The number of elements pointed to by `data`.
        pub datalen: usize
 }
-impl CVec_RouteHintZ {
-       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::lightning_invoice::RouteHint> {
+impl CVec_ChannelDetailsZ {
+       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::lightning::ln::channelmanager::ChannelDetails> {
                if self.datalen == 0 { return Vec::new(); }
                let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
                self.data = std::ptr::null_mut();
                self.datalen = 0;
                ret
        }
-       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::lightning_invoice::RouteHint] {
+       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::lightning::ln::channelmanager::ChannelDetails] {
                unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
        }
 }
-impl From<Vec<crate::lightning_invoice::RouteHint>> for CVec_RouteHintZ {
-       fn from(v: Vec<crate::lightning_invoice::RouteHint>) -> Self {
+impl From<Vec<crate::lightning::ln::channelmanager::ChannelDetails>> for CVec_ChannelDetailsZ {
+       fn from(v: Vec<crate::lightning::ln::channelmanager::ChannelDetails>) -> Self {
                let datalen = v.len();
                let data = Box::into_raw(v.into_boxed_slice());
                Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
@@ -1812,14 +1645,14 @@ impl From<Vec<crate::lightning_invoice::RouteHint>> for CVec_RouteHintZ {
 }
 #[no_mangle]
 /// Frees the buffer pointed to by `data` if `datalen` is non-0.
-pub extern "C" fn CVec_RouteHintZ_free(_res: CVec_RouteHintZ) { }
-impl Drop for CVec_RouteHintZ {
+pub extern "C" fn CVec_ChannelDetailsZ_free(_res: CVec_ChannelDetailsZ) { }
+impl Drop for CVec_ChannelDetailsZ {
        fn drop(&mut self) {
                if self.datalen == 0 { return; }
                unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
        }
 }
-impl Clone for CVec_RouteHintZ {
+impl Clone for CVec_ChannelDetailsZ {
        fn clone(&self) -> Self {
                let mut res = Vec::new();
                if self.datalen == 0 { return Self::from(res); }
@@ -1828,84 +1661,96 @@ impl Clone for CVec_RouteHintZ {
        }
 }
 #[repr(C)]
-#[derive(Clone)]
-/// An enum which can either contain a u64 or not
-pub enum COption_u64Z {
-       /// When we're in this state, this COption_u64Z contains a u64
-       Some(u64),
-       /// When we're in this state, this COption_u64Z contains nothing
-       None
+/// A dynamically-allocated array of crate::lightning::routing::router::RouteHintHops of arbitrary size.
+/// This corresponds to std::vector in C++
+pub struct CVec_RouteHintHopZ {
+       /// The elements in the array.
+       /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+       pub data: *mut crate::lightning::routing::router::RouteHintHop,
+       /// The number of elements pointed to by `data`.
+       pub datalen: usize
 }
-impl COption_u64Z {
-       #[allow(unused)] pub(crate) fn is_some(&self) -> bool {
-               if let Self::Some(_) = self { true } else { false }
+impl CVec_RouteHintHopZ {
+       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::lightning::routing::router::RouteHintHop> {
+               if self.datalen == 0 { return Vec::new(); }
+               let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
+               self.data = std::ptr::null_mut();
+               self.datalen = 0;
+               ret
        }
-       #[allow(unused)] pub(crate) fn take(mut self) -> u64 {
-               if let Self::Some(v) = self { v } else { unreachable!() }
+       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::lightning::routing::router::RouteHintHop] {
+               unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
        }
 }
-#[no_mangle]
-/// Constructs a new COption_u64Z containing a u64
-pub extern "C" fn COption_u64Z_some(o: u64) -> COption_u64Z {
-       COption_u64Z::Some(o)
+impl From<Vec<crate::lightning::routing::router::RouteHintHop>> for CVec_RouteHintHopZ {
+       fn from(v: Vec<crate::lightning::routing::router::RouteHintHop>) -> Self {
+               let datalen = v.len();
+               let data = Box::into_raw(v.into_boxed_slice());
+               Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
+       }
 }
 #[no_mangle]
-/// Constructs a new COption_u64Z containing nothing
-pub extern "C" fn COption_u64Z_none() -> COption_u64Z {
-       COption_u64Z::None
+/// Frees the buffer pointed to by `data` if `datalen` is non-0.
+pub extern "C" fn CVec_RouteHintHopZ_free(_res: CVec_RouteHintHopZ) { }
+impl Drop for CVec_RouteHintHopZ {
+       fn drop(&mut self) {
+               if self.datalen == 0 { return; }
+               unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
+       }
+}
+impl Clone for CVec_RouteHintHopZ {
+       fn clone(&self) -> Self {
+               let mut res = Vec::new();
+               if self.datalen == 0 { return Self::from(res); }
+               res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
+               Self::from(res)
+       }
 }
-#[no_mangle]
-/// Frees any resources associated with the u64, if we are in the Some state
-pub extern "C" fn COption_u64Z_free(_res: COption_u64Z) { }
-#[no_mangle]
-/// Creates a new COption_u64Z which has the same data as `orig`
-/// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn COption_u64Z_clone(orig: &COption_u64Z) -> COption_u64Z { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_PositiveTimestampCreationErrorZ
-pub union CResult_PositiveTimestampCreationErrorZPtr {
+/// The contents of CResult_RouteLightningErrorZ
+pub union CResult_RouteLightningErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning_invoice::PositiveTimestamp,
+       pub result: *mut crate::lightning::routing::router::Route,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::lightning_invoice::CreationError,
+       pub err: *mut crate::lightning::ln::msgs::LightningError,
 }
 #[repr(C)]
-/// 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.
+/// 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`.
-pub struct CResult_PositiveTimestampCreationErrorZ {
-       /// The contents of this CResult_PositiveTimestampCreationErrorZ, accessible via either
+pub struct CResult_RouteLightningErrorZ {
+       /// The contents of this CResult_RouteLightningErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_PositiveTimestampCreationErrorZPtr,
-       /// Whether this CResult_PositiveTimestampCreationErrorZ represents a success state.
+       pub contents: CResult_RouteLightningErrorZPtr,
+       /// Whether this CResult_RouteLightningErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_PositiveTimestampCreationErrorZ in the success state.
-pub extern "C" fn CResult_PositiveTimestampCreationErrorZ_ok(o: crate::lightning_invoice::PositiveTimestamp) -> CResult_PositiveTimestampCreationErrorZ {
-       CResult_PositiveTimestampCreationErrorZ {
-               contents: CResult_PositiveTimestampCreationErrorZPtr {
+/// Creates a new CResult_RouteLightningErrorZ in the success state.
+pub extern "C" fn CResult_RouteLightningErrorZ_ok(o: crate::lightning::routing::router::Route) -> CResult_RouteLightningErrorZ {
+       CResult_RouteLightningErrorZ {
+               contents: CResult_RouteLightningErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_PositiveTimestampCreationErrorZ in the error state.
-pub extern "C" fn CResult_PositiveTimestampCreationErrorZ_err(e: crate::lightning_invoice::CreationError) -> CResult_PositiveTimestampCreationErrorZ {
-       CResult_PositiveTimestampCreationErrorZ {
-               contents: CResult_PositiveTimestampCreationErrorZPtr {
+/// Creates a new CResult_RouteLightningErrorZ in the error state.
+pub extern "C" fn CResult_RouteLightningErrorZ_err(e: crate::lightning::ln::msgs::LightningError) -> CResult_RouteLightningErrorZ {
+       CResult_RouteLightningErrorZ {
+               contents: CResult_RouteLightningErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_PositiveTimestampCreationErrorZ.
-pub extern "C" fn CResult_PositiveTimestampCreationErrorZ_free(_res: CResult_PositiveTimestampCreationErrorZ) { }
-impl Drop for CResult_PositiveTimestampCreationErrorZ {
+/// Frees any resources used by the CResult_RouteLightningErrorZ.
+pub extern "C" fn CResult_RouteLightningErrorZ_free(_res: CResult_RouteLightningErrorZ) { }
+impl Drop for CResult_RouteLightningErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -1918,16 +1763,16 @@ impl Drop for CResult_PositiveTimestampCreationErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning_invoice::PositiveTimestamp, crate::lightning_invoice::CreationError>> for CResult_PositiveTimestampCreationErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning_invoice::PositiveTimestamp, crate::lightning_invoice::CreationError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::routing::router::Route, crate::lightning::ln::msgs::LightningError>> for CResult_RouteLightningErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::routing::router::Route, crate::lightning::ln::msgs::LightningError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_PositiveTimestampCreationErrorZPtr { result }
+                       CResult_RouteLightningErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_PositiveTimestampCreationErrorZPtr { err }
+                       CResult_RouteLightningErrorZPtr { err }
                };
                Self {
                        contents,
@@ -1935,69 +1780,73 @@ impl From<crate::c_types::CResultTempl<crate::lightning_invoice::PositiveTimesta
                }
        }
 }
-impl Clone for CResult_PositiveTimestampCreationErrorZ {
+impl Clone for CResult_RouteLightningErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_PositiveTimestampCreationErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning_invoice::PositiveTimestamp>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_RouteLightningErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::routing::router::Route>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_PositiveTimestampCreationErrorZPtr {
-                               err: Box::into_raw(Box::new(<crate::lightning_invoice::CreationError>::clone(unsafe { &*self.contents.err })))
+                       Self { result_ok: false, contents: CResult_RouteLightningErrorZPtr {
+                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::LightningError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_PositiveTimestampCreationErrorZ which has the same data as `orig`
+/// Creates a new CResult_RouteLightningErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_PositiveTimestampCreationErrorZ_clone(orig: &CResult_PositiveTimestampCreationErrorZ) -> CResult_PositiveTimestampCreationErrorZ { orig.clone() }
+pub extern "C" fn CResult_RouteLightningErrorZ_clone(orig: &CResult_RouteLightningErrorZ) -> CResult_RouteLightningErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_NoneSemanticErrorZ
-pub union CResult_NoneSemanticErrorZPtr {
-       /// Note that this value is always NULL, as there are no contents in the OK variant
-       pub result: *mut std::ffi::c_void,
+/// The contents of CResult_TxOutAccessErrorZ
+pub union CResult_TxOutAccessErrorZPtr {
+       /// A pointer to the contents in the success state.
+       /// Reading from this pointer when `result_ok` is not set is undefined.
+       pub result: *mut crate::c_types::TxOut,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::lightning_invoice::SemanticError,
+       pub err: *mut crate::lightning::chain::AccessError,
 }
 #[repr(C)]
-/// A CResult_NoneSemanticErrorZ represents the result of a fallible operation,
-/// containing a () on success and a crate::lightning_invoice::SemanticError 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`.
-pub struct CResult_NoneSemanticErrorZ {
-       /// The contents of this CResult_NoneSemanticErrorZ, accessible via either
+pub struct CResult_TxOutAccessErrorZ {
+       /// The contents of this CResult_TxOutAccessErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_NoneSemanticErrorZPtr,
-       /// Whether this CResult_NoneSemanticErrorZ represents a success state.
+       pub contents: CResult_TxOutAccessErrorZPtr,
+       /// Whether this CResult_TxOutAccessErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_NoneSemanticErrorZ in the success state.
-pub extern "C" fn CResult_NoneSemanticErrorZ_ok() -> CResult_NoneSemanticErrorZ {
-       CResult_NoneSemanticErrorZ {
-               contents: CResult_NoneSemanticErrorZPtr {
-                       result: std::ptr::null_mut(),
+/// Creates a new CResult_TxOutAccessErrorZ in the success state.
+pub extern "C" fn CResult_TxOutAccessErrorZ_ok(o: crate::c_types::TxOut) -> CResult_TxOutAccessErrorZ {
+       CResult_TxOutAccessErrorZ {
+               contents: CResult_TxOutAccessErrorZPtr {
+                       result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_NoneSemanticErrorZ in the error state.
-pub extern "C" fn CResult_NoneSemanticErrorZ_err(e: crate::lightning_invoice::SemanticError) -> CResult_NoneSemanticErrorZ {
-       CResult_NoneSemanticErrorZ {
-               contents: CResult_NoneSemanticErrorZPtr {
+/// Creates a new CResult_TxOutAccessErrorZ in the error state.
+pub extern "C" fn CResult_TxOutAccessErrorZ_err(e: crate::lightning::chain::AccessError) -> CResult_TxOutAccessErrorZ {
+       CResult_TxOutAccessErrorZ {
+               contents: CResult_TxOutAccessErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_NoneSemanticErrorZ.
-pub extern "C" fn CResult_NoneSemanticErrorZ_free(_res: CResult_NoneSemanticErrorZ) { }
-impl Drop for CResult_NoneSemanticErrorZ {
+/// Frees any resources used by the CResult_TxOutAccessErrorZ.
+pub extern "C" fn CResult_TxOutAccessErrorZ_free(_res: CResult_TxOutAccessErrorZ) { }
+impl Drop for CResult_TxOutAccessErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
+                       if unsafe { !(self.contents.result as *mut ()).is_null() } {
+                               let _ = unsafe { Box::from_raw(self.contents.result) };
+                       }
                } else {
                        if unsafe { !(self.contents.err as *mut ()).is_null() } {
                                let _ = unsafe { Box::from_raw(self.contents.err) };
@@ -2005,16 +1854,16 @@ impl Drop for CResult_NoneSemanticErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<(), crate::lightning_invoice::SemanticError>> for CResult_NoneSemanticErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<(), crate::lightning_invoice::SemanticError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::c_types::TxOut, crate::lightning::chain::AccessError>> for CResult_TxOutAccessErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::c_types::TxOut, crate::lightning::chain::AccessError>) -> Self {
                let contents = if o.result_ok {
-                       let _ = unsafe { Box::from_raw(o.contents.result) };
-                       o.contents.result = std::ptr::null_mut();
-                       CResult_NoneSemanticErrorZPtr { result: std::ptr::null_mut() }
+                       let result = unsafe { o.contents.result };
+                       unsafe { o.contents.result = std::ptr::null_mut() };
+                       CResult_TxOutAccessErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_NoneSemanticErrorZPtr { err }
+                       CResult_TxOutAccessErrorZPtr { err }
                };
                Self {
                        contents,
@@ -2022,255 +1871,203 @@ impl From<crate::c_types::CResultTempl<(), crate::lightning_invoice::SemanticErr
                }
        }
 }
-impl Clone for CResult_NoneSemanticErrorZ {
+impl Clone for CResult_TxOutAccessErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_NoneSemanticErrorZPtr {
-                               result: std::ptr::null_mut()
+                       Self { result_ok: true, contents: CResult_TxOutAccessErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::c_types::TxOut>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_NoneSemanticErrorZPtr {
-                               err: Box::into_raw(Box::new(<crate::lightning_invoice::SemanticError>::clone(unsafe { &*self.contents.err })))
+                       Self { result_ok: false, contents: CResult_TxOutAccessErrorZPtr {
+                               err: Box::into_raw(Box::new(<crate::lightning::chain::AccessError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_NoneSemanticErrorZ which has the same data as `orig`
+/// Creates a new CResult_TxOutAccessErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_NoneSemanticErrorZ_clone(orig: &CResult_NoneSemanticErrorZ) -> CResult_NoneSemanticErrorZ { orig.clone() }
-#[repr(C)]
-/// The contents of CResult_InvoiceSemanticErrorZ
-pub union CResult_InvoiceSemanticErrorZPtr {
-       /// A pointer to the contents in the success state.
-       /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning_invoice::Invoice,
-       /// A pointer to the contents in the error state.
-       /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::lightning_invoice::SemanticError,
-}
+pub extern "C" fn CResult_TxOutAccessErrorZ_clone(orig: &CResult_TxOutAccessErrorZ) -> CResult_TxOutAccessErrorZ { orig.clone() }
 #[repr(C)]
-/// 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`.
-pub struct CResult_InvoiceSemanticErrorZ {
-       /// The contents of this CResult_InvoiceSemanticErrorZ, accessible via either
-       /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_InvoiceSemanticErrorZPtr,
-       /// Whether this CResult_InvoiceSemanticErrorZ represents a success state.
-       pub result_ok: bool,
-}
-#[no_mangle]
-/// Creates a new CResult_InvoiceSemanticErrorZ in the success state.
-pub extern "C" fn CResult_InvoiceSemanticErrorZ_ok(o: crate::lightning_invoice::Invoice) -> CResult_InvoiceSemanticErrorZ {
-       CResult_InvoiceSemanticErrorZ {
-               contents: CResult_InvoiceSemanticErrorZPtr {
-                       result: Box::into_raw(Box::new(o)),
-               },
-               result_ok: true,
-       }
-}
-#[no_mangle]
-/// Creates a new CResult_InvoiceSemanticErrorZ in the error state.
-pub extern "C" fn CResult_InvoiceSemanticErrorZ_err(e: crate::lightning_invoice::SemanticError) -> CResult_InvoiceSemanticErrorZ {
-       CResult_InvoiceSemanticErrorZ {
-               contents: CResult_InvoiceSemanticErrorZPtr {
-                       err: Box::into_raw(Box::new(e)),
-               },
-               result_ok: false,
-       }
+/// A tuple of 2 elements. See the individual fields for the types contained.
+pub struct C2Tuple_usizeTransactionZ {
+       /// The element at position 0
+       pub a: usize,
+       /// The element at position 1
+       pub b: crate::c_types::Transaction,
 }
-#[no_mangle]
-/// Frees any resources used by the CResult_InvoiceSemanticErrorZ.
-pub extern "C" fn CResult_InvoiceSemanticErrorZ_free(_res: CResult_InvoiceSemanticErrorZ) { }
-impl Drop for CResult_InvoiceSemanticErrorZ {
-       fn drop(&mut self) {
-               if self.result_ok {
-                       if unsafe { !(self.contents.result as *mut ()).is_null() } {
-                               let _ = unsafe { Box::from_raw(self.contents.result) };
-                       }
-               } else {
-                       if unsafe { !(self.contents.err as *mut ()).is_null() } {
-                               let _ = unsafe { Box::from_raw(self.contents.err) };
-                       }
+impl From<(usize, crate::c_types::Transaction)> for C2Tuple_usizeTransactionZ {
+       fn from (tup: (usize, crate::c_types::Transaction)) -> Self {
+               Self {
+                       a: tup.0,
+                       b: tup.1,
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning_invoice::Invoice, crate::lightning_invoice::SemanticError>> for CResult_InvoiceSemanticErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning_invoice::Invoice, crate::lightning_invoice::SemanticError>) -> Self {
-               let contents = if o.result_ok {
-                       let result = unsafe { o.contents.result };
-                       unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_InvoiceSemanticErrorZPtr { result }
-               } else {
-                       let err = unsafe { o.contents.err };
-                       unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_InvoiceSemanticErrorZPtr { err }
-               };
-               Self {
-                       contents,
-                       result_ok: o.result_ok,
-               }
+impl C2Tuple_usizeTransactionZ {
+       #[allow(unused)] pub(crate) fn to_rust(mut self) -> (usize, crate::c_types::Transaction) {
+               (self.a, self.b)
        }
 }
-impl Clone for CResult_InvoiceSemanticErrorZ {
+impl Clone for C2Tuple_usizeTransactionZ {
        fn clone(&self) -> Self {
-               if self.result_ok {
-                       Self { result_ok: true, contents: CResult_InvoiceSemanticErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning_invoice::Invoice>::clone(unsafe { &*self.contents.result })))
-                       } }
-               } else {
-                       Self { result_ok: false, contents: CResult_InvoiceSemanticErrorZPtr {
-                               err: Box::into_raw(Box::new(<crate::lightning_invoice::SemanticError>::clone(unsafe { &*self.contents.err })))
-                       } }
+               Self {
+                       a: self.a.clone(),
+                       b: self.b.clone(),
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_InvoiceSemanticErrorZ which has the same data as `orig`
+/// Creates a new tuple which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_InvoiceSemanticErrorZ_clone(orig: &CResult_InvoiceSemanticErrorZ) -> CResult_InvoiceSemanticErrorZ { orig.clone() }
-#[repr(C)]
-/// The contents of CResult_DescriptionCreationErrorZ
-pub union CResult_DescriptionCreationErrorZPtr {
-       /// A pointer to the contents in the success state.
-       /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning_invoice::Description,
-       /// A pointer to the contents in the error state.
-       /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::lightning_invoice::CreationError,
+pub extern "C" fn C2Tuple_usizeTransactionZ_clone(orig: &C2Tuple_usizeTransactionZ) -> C2Tuple_usizeTransactionZ { orig.clone() }
+/// Creates a new C2Tuple_usizeTransactionZ from the contained elements.
+#[no_mangle]
+pub extern "C" fn C2Tuple_usizeTransactionZ_new(a: usize, b: crate::c_types::Transaction) -> C2Tuple_usizeTransactionZ {
+       C2Tuple_usizeTransactionZ { a, b, }
 }
+
+#[no_mangle]
+/// Frees any resources used by the C2Tuple_usizeTransactionZ.
+pub extern "C" fn C2Tuple_usizeTransactionZ_free(_res: C2Tuple_usizeTransactionZ) { }
 #[repr(C)]
-/// 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`.
-pub struct CResult_DescriptionCreationErrorZ {
-       /// The contents of this CResult_DescriptionCreationErrorZ, accessible via either
-       /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_DescriptionCreationErrorZPtr,
-       /// Whether this CResult_DescriptionCreationErrorZ represents a success state.
-       pub result_ok: bool,
+/// A dynamically-allocated array of crate::c_types::derived::C2Tuple_usizeTransactionZs of arbitrary size.
+/// This corresponds to std::vector in C++
+pub struct CVec_C2Tuple_usizeTransactionZZ {
+       /// The elements in the array.
+       /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+       pub data: *mut crate::c_types::derived::C2Tuple_usizeTransactionZ,
+       /// The number of elements pointed to by `data`.
+       pub datalen: usize
 }
-#[no_mangle]
-/// Creates a new CResult_DescriptionCreationErrorZ in the success state.
-pub extern "C" fn CResult_DescriptionCreationErrorZ_ok(o: crate::lightning_invoice::Description) -> CResult_DescriptionCreationErrorZ {
-       CResult_DescriptionCreationErrorZ {
-               contents: CResult_DescriptionCreationErrorZPtr {
-                       result: Box::into_raw(Box::new(o)),
-               },
-               result_ok: true,
+impl CVec_C2Tuple_usizeTransactionZZ {
+       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::c_types::derived::C2Tuple_usizeTransactionZ> {
+               if self.datalen == 0 { return Vec::new(); }
+               let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
+               self.data = std::ptr::null_mut();
+               self.datalen = 0;
+               ret
+       }
+       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::c_types::derived::C2Tuple_usizeTransactionZ] {
+               unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
        }
 }
-#[no_mangle]
-/// Creates a new CResult_DescriptionCreationErrorZ in the error state.
-pub extern "C" fn CResult_DescriptionCreationErrorZ_err(e: crate::lightning_invoice::CreationError) -> CResult_DescriptionCreationErrorZ {
-       CResult_DescriptionCreationErrorZ {
-               contents: CResult_DescriptionCreationErrorZPtr {
-                       err: Box::into_raw(Box::new(e)),
-               },
-               result_ok: false,
+impl From<Vec<crate::c_types::derived::C2Tuple_usizeTransactionZ>> for CVec_C2Tuple_usizeTransactionZZ {
+       fn from(v: Vec<crate::c_types::derived::C2Tuple_usizeTransactionZ>) -> Self {
+               let datalen = v.len();
+               let data = Box::into_raw(v.into_boxed_slice());
+               Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_DescriptionCreationErrorZ.
-pub extern "C" fn CResult_DescriptionCreationErrorZ_free(_res: CResult_DescriptionCreationErrorZ) { }
-impl Drop for CResult_DescriptionCreationErrorZ {
-       fn drop(&mut self) {
-               if self.result_ok {
-                       if unsafe { !(self.contents.result as *mut ()).is_null() } {
-                               let _ = unsafe { Box::from_raw(self.contents.result) };
-                       }
-               } else {
-                       if unsafe { !(self.contents.err as *mut ()).is_null() } {
-                               let _ = unsafe { Box::from_raw(self.contents.err) };
-                       }
-               }
+/// Frees the buffer pointed to by `data` if `datalen` is non-0.
+pub extern "C" fn CVec_C2Tuple_usizeTransactionZZ_free(_res: CVec_C2Tuple_usizeTransactionZZ) { }
+impl Drop for CVec_C2Tuple_usizeTransactionZZ {
+       fn drop(&mut self) {
+               if self.datalen == 0 { return; }
+               unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning_invoice::Description, crate::lightning_invoice::CreationError>> for CResult_DescriptionCreationErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning_invoice::Description, crate::lightning_invoice::CreationError>) -> Self {
-               let contents = if o.result_ok {
-                       let result = unsafe { o.contents.result };
-                       unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_DescriptionCreationErrorZPtr { result }
-               } else {
-                       let err = unsafe { o.contents.err };
-                       unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_DescriptionCreationErrorZPtr { err }
-               };
-               Self {
-                       contents,
-                       result_ok: o.result_ok,
-               }
+impl Clone for CVec_C2Tuple_usizeTransactionZZ {
+       fn clone(&self) -> Self {
+               let mut res = Vec::new();
+               if self.datalen == 0 { return Self::from(res); }
+               res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
+               Self::from(res)
        }
 }
-impl Clone for CResult_DescriptionCreationErrorZ {
-       fn clone(&self) -> Self {
-               if self.result_ok {
-                       Self { result_ok: true, contents: CResult_DescriptionCreationErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning_invoice::Description>::clone(unsafe { &*self.contents.result })))
-                       } }
-               } else {
-                       Self { result_ok: false, contents: CResult_DescriptionCreationErrorZPtr {
-                               err: Box::into_raw(Box::new(<crate::lightning_invoice::CreationError>::clone(unsafe { &*self.contents.err })))
-                       } }
-               }
+#[repr(C)]
+/// A dynamically-allocated array of crate::c_types::ThirtyTwoBytess of arbitrary size.
+/// This corresponds to std::vector in C++
+pub struct CVec_TxidZ {
+       /// The elements in the array.
+       /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+       pub data: *mut crate::c_types::ThirtyTwoBytes,
+       /// The number of elements pointed to by `data`.
+       pub datalen: usize
+}
+impl CVec_TxidZ {
+       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::c_types::ThirtyTwoBytes> {
+               if self.datalen == 0 { return Vec::new(); }
+               let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
+               self.data = std::ptr::null_mut();
+               self.datalen = 0;
+               ret
+       }
+       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::c_types::ThirtyTwoBytes] {
+               unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
+       }
+}
+impl From<Vec<crate::c_types::ThirtyTwoBytes>> for CVec_TxidZ {
+       fn from(v: Vec<crate::c_types::ThirtyTwoBytes>) -> Self {
+               let datalen = v.len();
+               let data = Box::into_raw(v.into_boxed_slice());
+               Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_DescriptionCreationErrorZ which has the same data as `orig`
-/// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_DescriptionCreationErrorZ_clone(orig: &CResult_DescriptionCreationErrorZ) -> CResult_DescriptionCreationErrorZ { orig.clone() }
+/// Frees the buffer pointed to by `data` if `datalen` is non-0.
+pub extern "C" fn CVec_TxidZ_free(_res: CVec_TxidZ) { }
+impl Drop for CVec_TxidZ {
+       fn drop(&mut self) {
+               if self.datalen == 0 { return; }
+               unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
+       }
+}
+impl Clone for CVec_TxidZ {
+       fn clone(&self) -> Self {
+               let mut res = Vec::new();
+               if self.datalen == 0 { return Self::from(res); }
+               res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
+               Self::from(res)
+       }
+}
 #[repr(C)]
-/// The contents of CResult_ExpiryTimeCreationErrorZ
-pub union CResult_ExpiryTimeCreationErrorZPtr {
-       /// A pointer to the contents in the success state.
-       /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning_invoice::ExpiryTime,
+/// The contents of CResult_NoneChannelMonitorUpdateErrZ
+pub union CResult_NoneChannelMonitorUpdateErrZPtr {
+       /// Note that this value is always NULL, as there are no contents in the OK variant
+       pub result: *mut std::ffi::c_void,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::lightning_invoice::CreationError,
+       pub err: *mut crate::lightning::chain::channelmonitor::ChannelMonitorUpdateErr,
 }
 #[repr(C)]
-/// 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.
+/// 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`.
-pub struct CResult_ExpiryTimeCreationErrorZ {
-       /// The contents of this CResult_ExpiryTimeCreationErrorZ, accessible via either
+pub struct CResult_NoneChannelMonitorUpdateErrZ {
+       /// The contents of this CResult_NoneChannelMonitorUpdateErrZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_ExpiryTimeCreationErrorZPtr,
-       /// Whether this CResult_ExpiryTimeCreationErrorZ represents a success state.
+       pub contents: CResult_NoneChannelMonitorUpdateErrZPtr,
+       /// Whether this CResult_NoneChannelMonitorUpdateErrZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_ExpiryTimeCreationErrorZ in the success state.
-pub extern "C" fn CResult_ExpiryTimeCreationErrorZ_ok(o: crate::lightning_invoice::ExpiryTime) -> CResult_ExpiryTimeCreationErrorZ {
-       CResult_ExpiryTimeCreationErrorZ {
-               contents: CResult_ExpiryTimeCreationErrorZPtr {
-                       result: Box::into_raw(Box::new(o)),
+/// Creates a new CResult_NoneChannelMonitorUpdateErrZ in the success state.
+pub extern "C" fn CResult_NoneChannelMonitorUpdateErrZ_ok() -> CResult_NoneChannelMonitorUpdateErrZ {
+       CResult_NoneChannelMonitorUpdateErrZ {
+               contents: CResult_NoneChannelMonitorUpdateErrZPtr {
+                       result: std::ptr::null_mut(),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_ExpiryTimeCreationErrorZ in the error state.
-pub extern "C" fn CResult_ExpiryTimeCreationErrorZ_err(e: crate::lightning_invoice::CreationError) -> CResult_ExpiryTimeCreationErrorZ {
-       CResult_ExpiryTimeCreationErrorZ {
-               contents: CResult_ExpiryTimeCreationErrorZPtr {
+/// Creates a new CResult_NoneChannelMonitorUpdateErrZ in the error state.
+pub extern "C" fn CResult_NoneChannelMonitorUpdateErrZ_err(e: crate::lightning::chain::channelmonitor::ChannelMonitorUpdateErr) -> CResult_NoneChannelMonitorUpdateErrZ {
+       CResult_NoneChannelMonitorUpdateErrZ {
+               contents: CResult_NoneChannelMonitorUpdateErrZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_ExpiryTimeCreationErrorZ.
-pub extern "C" fn CResult_ExpiryTimeCreationErrorZ_free(_res: CResult_ExpiryTimeCreationErrorZ) { }
-impl Drop for CResult_ExpiryTimeCreationErrorZ {
+/// Frees any resources used by the CResult_NoneChannelMonitorUpdateErrZ.
+pub extern "C" fn CResult_NoneChannelMonitorUpdateErrZ_free(_res: CResult_NoneChannelMonitorUpdateErrZ) { }
+impl Drop for CResult_NoneChannelMonitorUpdateErrZ {
        fn drop(&mut self) {
                if self.result_ok {
-                       if unsafe { !(self.contents.result as *mut ()).is_null() } {
-                               let _ = unsafe { Box::from_raw(self.contents.result) };
-                       }
                } else {
                        if unsafe { !(self.contents.err as *mut ()).is_null() } {
                                let _ = unsafe { Box::from_raw(self.contents.err) };
@@ -2278,16 +2075,16 @@ impl Drop for CResult_ExpiryTimeCreationErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning_invoice::ExpiryTime, crate::lightning_invoice::CreationError>> for CResult_ExpiryTimeCreationErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning_invoice::ExpiryTime, crate::lightning_invoice::CreationError>) -> Self {
+impl From<crate::c_types::CResultTempl<(), crate::lightning::chain::channelmonitor::ChannelMonitorUpdateErr>> for CResult_NoneChannelMonitorUpdateErrZ {
+       fn from(mut o: crate::c_types::CResultTempl<(), crate::lightning::chain::channelmonitor::ChannelMonitorUpdateErr>) -> Self {
                let contents = if o.result_ok {
-                       let result = unsafe { o.contents.result };
-                       unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_ExpiryTimeCreationErrorZPtr { result }
+                       let _ = unsafe { Box::from_raw(o.contents.result) };
+                       o.contents.result = std::ptr::null_mut();
+                       CResult_NoneChannelMonitorUpdateErrZPtr { result: std::ptr::null_mut() }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_ExpiryTimeCreationErrorZPtr { err }
+                       CResult_NoneChannelMonitorUpdateErrZPtr { err }
                };
                Self {
                        contents,
@@ -2295,47 +2092,47 @@ impl From<crate::c_types::CResultTempl<crate::lightning_invoice::ExpiryTime, cra
                }
        }
 }
-impl Clone for CResult_ExpiryTimeCreationErrorZ {
+impl Clone for CResult_NoneChannelMonitorUpdateErrZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_ExpiryTimeCreationErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning_invoice::ExpiryTime>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_NoneChannelMonitorUpdateErrZPtr {
+                               result: std::ptr::null_mut()
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_ExpiryTimeCreationErrorZPtr {
-                               err: Box::into_raw(Box::new(<crate::lightning_invoice::CreationError>::clone(unsafe { &*self.contents.err })))
+                       Self { result_ok: false, contents: CResult_NoneChannelMonitorUpdateErrZPtr {
+                               err: Box::into_raw(Box::new(<crate::lightning::chain::channelmonitor::ChannelMonitorUpdateErr>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_ExpiryTimeCreationErrorZ which has the same data as `orig`
+/// Creates a new CResult_NoneChannelMonitorUpdateErrZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_ExpiryTimeCreationErrorZ_clone(orig: &CResult_ExpiryTimeCreationErrorZ) -> CResult_ExpiryTimeCreationErrorZ { orig.clone() }
+pub extern "C" fn CResult_NoneChannelMonitorUpdateErrZ_clone(orig: &CResult_NoneChannelMonitorUpdateErrZ) -> CResult_NoneChannelMonitorUpdateErrZ { orig.clone() }
 #[repr(C)]
-/// A dynamically-allocated array of crate::lightning::routing::router::RouteHintHops of arbitrary size.
+/// A dynamically-allocated array of crate::lightning::chain::channelmonitor::MonitorEvents of arbitrary size.
 /// This corresponds to std::vector in C++
-pub struct CVec_RouteHintHopZ {
+pub struct CVec_MonitorEventZ {
        /// The elements in the array.
        /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
-       pub data: *mut crate::lightning::routing::router::RouteHintHop,
+       pub data: *mut crate::lightning::chain::channelmonitor::MonitorEvent,
        /// The number of elements pointed to by `data`.
        pub datalen: usize
 }
-impl CVec_RouteHintHopZ {
-       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::lightning::routing::router::RouteHintHop> {
+impl CVec_MonitorEventZ {
+       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::lightning::chain::channelmonitor::MonitorEvent> {
                if self.datalen == 0 { return Vec::new(); }
                let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
                self.data = std::ptr::null_mut();
                self.datalen = 0;
                ret
        }
-       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::lightning::routing::router::RouteHintHop] {
+       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::lightning::chain::channelmonitor::MonitorEvent] {
                unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
        }
 }
-impl From<Vec<crate::lightning::routing::router::RouteHintHop>> for CVec_RouteHintHopZ {
-       fn from(v: Vec<crate::lightning::routing::router::RouteHintHop>) -> Self {
+impl From<Vec<crate::lightning::chain::channelmonitor::MonitorEvent>> for CVec_MonitorEventZ {
+       fn from(v: Vec<crate::lightning::chain::channelmonitor::MonitorEvent>) -> Self {
                let datalen = v.len();
                let data = Box::into_raw(v.into_boxed_slice());
                Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
@@ -2343,14 +2140,14 @@ impl From<Vec<crate::lightning::routing::router::RouteHintHop>> for CVec_RouteHi
 }
 #[no_mangle]
 /// Frees the buffer pointed to by `data` if `datalen` is non-0.
-pub extern "C" fn CVec_RouteHintHopZ_free(_res: CVec_RouteHintHopZ) { }
-impl Drop for CVec_RouteHintHopZ {
+pub extern "C" fn CVec_MonitorEventZ_free(_res: CVec_MonitorEventZ) { }
+impl Drop for CVec_MonitorEventZ {
        fn drop(&mut self) {
                if self.datalen == 0 { return; }
                unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
        }
 }
-impl Clone for CVec_RouteHintHopZ {
+impl Clone for CVec_MonitorEventZ {
        fn clone(&self) -> Self {
                let mut res = Vec::new();
                if self.datalen == 0 { return Self::from(res); }
@@ -2359,141 +2156,176 @@ impl Clone for CVec_RouteHintHopZ {
        }
 }
 #[repr(C)]
-/// The contents of CResult_RouteHintCreationErrorZ
-pub union CResult_RouteHintCreationErrorZPtr {
-       /// A pointer to the contents in the success state.
-       /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning_invoice::RouteHint,
-       /// A pointer to the contents in the error state.
-       /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::lightning_invoice::CreationError,
-}
-#[repr(C)]
-/// 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`.
-pub struct CResult_RouteHintCreationErrorZ {
-       /// The contents of this CResult_RouteHintCreationErrorZ, accessible via either
-       /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_RouteHintCreationErrorZPtr,
-       /// Whether this CResult_RouteHintCreationErrorZ represents a success state.
-       pub result_ok: bool,
+#[derive(Clone)]
+/// An enum which can either contain a crate::c_types::derived::C2Tuple_usizeTransactionZ or not
+pub enum COption_C2Tuple_usizeTransactionZZ {
+       /// When we're in this state, this COption_C2Tuple_usizeTransactionZZ contains a crate::c_types::derived::C2Tuple_usizeTransactionZ
+       Some(crate::c_types::derived::C2Tuple_usizeTransactionZ),
+       /// When we're in this state, this COption_C2Tuple_usizeTransactionZZ contains nothing
+       None
 }
-#[no_mangle]
-/// Creates a new CResult_RouteHintCreationErrorZ in the success state.
-pub extern "C" fn CResult_RouteHintCreationErrorZ_ok(o: crate::lightning_invoice::RouteHint) -> CResult_RouteHintCreationErrorZ {
-       CResult_RouteHintCreationErrorZ {
-               contents: CResult_RouteHintCreationErrorZPtr {
-                       result: Box::into_raw(Box::new(o)),
-               },
-               result_ok: true,
+impl COption_C2Tuple_usizeTransactionZZ {
+       #[allow(unused)] pub(crate) fn is_some(&self) -> bool {
+               if let Self::Some(_) = self { true } else { false }
+       }
+       #[allow(unused)] pub(crate) fn take(mut self) -> crate::c_types::derived::C2Tuple_usizeTransactionZ {
+               if let Self::Some(v) = self { v } else { unreachable!() }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_RouteHintCreationErrorZ in the error state.
-pub extern "C" fn CResult_RouteHintCreationErrorZ_err(e: crate::lightning_invoice::CreationError) -> CResult_RouteHintCreationErrorZ {
-       CResult_RouteHintCreationErrorZ {
-               contents: CResult_RouteHintCreationErrorZPtr {
-                       err: Box::into_raw(Box::new(e)),
-               },
-               result_ok: false,
-       }
+/// Constructs a new COption_C2Tuple_usizeTransactionZZ containing a crate::c_types::derived::C2Tuple_usizeTransactionZ
+pub extern "C" fn COption_C2Tuple_usizeTransactionZZ_some(o: crate::c_types::derived::C2Tuple_usizeTransactionZ) -> COption_C2Tuple_usizeTransactionZZ {
+       COption_C2Tuple_usizeTransactionZZ::Some(o)
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_RouteHintCreationErrorZ.
-pub extern "C" fn CResult_RouteHintCreationErrorZ_free(_res: CResult_RouteHintCreationErrorZ) { }
-impl Drop for CResult_RouteHintCreationErrorZ {
-       fn drop(&mut self) {
-               if self.result_ok {
-                       if unsafe { !(self.contents.result as *mut ()).is_null() } {
-                               let _ = unsafe { Box::from_raw(self.contents.result) };
-                       }
-               } else {
-                       if unsafe { !(self.contents.err as *mut ()).is_null() } {
-                               let _ = unsafe { Box::from_raw(self.contents.err) };
-                       }
-               }
-       }
+/// Constructs a new COption_C2Tuple_usizeTransactionZZ containing nothing
+pub extern "C" fn COption_C2Tuple_usizeTransactionZZ_none() -> COption_C2Tuple_usizeTransactionZZ {
+       COption_C2Tuple_usizeTransactionZZ::None
 }
-impl From<crate::c_types::CResultTempl<crate::lightning_invoice::RouteHint, crate::lightning_invoice::CreationError>> for CResult_RouteHintCreationErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning_invoice::RouteHint, crate::lightning_invoice::CreationError>) -> Self {
-               let contents = if o.result_ok {
-                       let result = unsafe { o.contents.result };
-                       unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_RouteHintCreationErrorZPtr { result }
-               } else {
-                       let err = unsafe { o.contents.err };
-                       unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_RouteHintCreationErrorZPtr { err }
-               };
-               Self {
-                       contents,
-                       result_ok: o.result_ok,
-               }
+#[no_mangle]
+/// Frees any resources associated with the crate::c_types::derived::C2Tuple_usizeTransactionZ, if we are in the Some state
+pub extern "C" fn COption_C2Tuple_usizeTransactionZZ_free(_res: COption_C2Tuple_usizeTransactionZZ) { }
+#[no_mangle]
+/// Creates a new COption_C2Tuple_usizeTransactionZZ which has the same data as `orig`
+/// but with all dynamically-allocated buffers duplicated in new buffers.
+pub extern "C" fn COption_C2Tuple_usizeTransactionZZ_clone(orig: &COption_C2Tuple_usizeTransactionZZ) -> COption_C2Tuple_usizeTransactionZZ { orig.clone() }
+#[repr(C)]
+/// A dynamically-allocated array of crate::lightning::chain::keysinterface::SpendableOutputDescriptors of arbitrary size.
+/// This corresponds to std::vector in C++
+pub struct CVec_SpendableOutputDescriptorZ {
+       /// The elements in the array.
+       /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+       pub data: *mut crate::lightning::chain::keysinterface::SpendableOutputDescriptor,
+       /// The number of elements pointed to by `data`.
+       pub datalen: usize
+}
+impl CVec_SpendableOutputDescriptorZ {
+       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::lightning::chain::keysinterface::SpendableOutputDescriptor> {
+               if self.datalen == 0 { return Vec::new(); }
+               let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
+               self.data = std::ptr::null_mut();
+               self.datalen = 0;
+               ret
+       }
+       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::lightning::chain::keysinterface::SpendableOutputDescriptor] {
+               unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
        }
 }
-impl Clone for CResult_RouteHintCreationErrorZ {
+impl From<Vec<crate::lightning::chain::keysinterface::SpendableOutputDescriptor>> for CVec_SpendableOutputDescriptorZ {
+       fn from(v: Vec<crate::lightning::chain::keysinterface::SpendableOutputDescriptor>) -> Self {
+               let datalen = v.len();
+               let data = Box::into_raw(v.into_boxed_slice());
+               Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
+       }
+}
+#[no_mangle]
+/// Frees the buffer pointed to by `data` if `datalen` is non-0.
+pub extern "C" fn CVec_SpendableOutputDescriptorZ_free(_res: CVec_SpendableOutputDescriptorZ) { }
+impl Drop for CVec_SpendableOutputDescriptorZ {
+       fn drop(&mut self) {
+               if self.datalen == 0 { return; }
+               unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
+       }
+}
+impl Clone for CVec_SpendableOutputDescriptorZ {
        fn clone(&self) -> Self {
-               if self.result_ok {
-                       Self { result_ok: true, contents: CResult_RouteHintCreationErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning_invoice::RouteHint>::clone(unsafe { &*self.contents.result })))
-                       } }
-               } else {
-                       Self { result_ok: false, contents: CResult_RouteHintCreationErrorZPtr {
-                               err: Box::into_raw(Box::new(<crate::lightning_invoice::CreationError>::clone(unsafe { &*self.contents.err })))
-                       } }
-               }
+               let mut res = Vec::new();
+               if self.datalen == 0 { return Self::from(res); }
+               res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
+               Self::from(res)
+       }
+}
+#[repr(C)]
+/// A dynamically-allocated array of crate::lightning::util::events::MessageSendEvents of arbitrary size.
+/// This corresponds to std::vector in C++
+pub struct CVec_MessageSendEventZ {
+       /// The elements in the array.
+       /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+       pub data: *mut crate::lightning::util::events::MessageSendEvent,
+       /// The number of elements pointed to by `data`.
+       pub datalen: usize
+}
+impl CVec_MessageSendEventZ {
+       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::lightning::util::events::MessageSendEvent> {
+               if self.datalen == 0 { return Vec::new(); }
+               let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
+               self.data = std::ptr::null_mut();
+               self.datalen = 0;
+               ret
+       }
+       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::lightning::util::events::MessageSendEvent] {
+               unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
+       }
+}
+impl From<Vec<crate::lightning::util::events::MessageSendEvent>> for CVec_MessageSendEventZ {
+       fn from(v: Vec<crate::lightning::util::events::MessageSendEvent>) -> Self {
+               let datalen = v.len();
+               let data = Box::into_raw(v.into_boxed_slice());
+               Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_RouteHintCreationErrorZ which has the same data as `orig`
-/// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_RouteHintCreationErrorZ_clone(orig: &CResult_RouteHintCreationErrorZ) -> CResult_RouteHintCreationErrorZ { orig.clone() }
+/// Frees the buffer pointed to by `data` if `datalen` is non-0.
+pub extern "C" fn CVec_MessageSendEventZ_free(_res: CVec_MessageSendEventZ) { }
+impl Drop for CVec_MessageSendEventZ {
+       fn drop(&mut self) {
+               if self.datalen == 0 { return; }
+               unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
+       }
+}
+impl Clone for CVec_MessageSendEventZ {
+       fn clone(&self) -> Self {
+               let mut res = Vec::new();
+               if self.datalen == 0 { return Self::from(res); }
+               res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
+               Self::from(res)
+       }
+}
 #[repr(C)]
-/// The contents of CResult_StringErrorZ
-pub union CResult_StringErrorZPtr {
+/// The contents of CResult_InitFeaturesDecodeErrorZ
+pub union CResult_InitFeaturesDecodeErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::c_types::Str,
+       pub result: *mut crate::lightning::ln::features::InitFeatures,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::c_types::Secp256k1Error,
+       pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// A CResult_StringErrorZ represents the result of a fallible operation,
-/// containing a crate::c_types::Str on success and a crate::c_types::Secp256k1Error 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`.
-pub struct CResult_StringErrorZ {
-       /// The contents of this CResult_StringErrorZ, accessible via either
+pub struct CResult_InitFeaturesDecodeErrorZ {
+       /// The contents of this CResult_InitFeaturesDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_StringErrorZPtr,
-       /// Whether this CResult_StringErrorZ represents a success state.
+       pub contents: CResult_InitFeaturesDecodeErrorZPtr,
+       /// Whether this CResult_InitFeaturesDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_StringErrorZ in the success state.
-pub extern "C" fn CResult_StringErrorZ_ok(o: crate::c_types::Str) -> CResult_StringErrorZ {
-       CResult_StringErrorZ {
-               contents: CResult_StringErrorZPtr {
+/// Creates a new CResult_InitFeaturesDecodeErrorZ in the success state.
+pub extern "C" fn CResult_InitFeaturesDecodeErrorZ_ok(o: crate::lightning::ln::features::InitFeatures) -> CResult_InitFeaturesDecodeErrorZ {
+       CResult_InitFeaturesDecodeErrorZ {
+               contents: CResult_InitFeaturesDecodeErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_StringErrorZ in the error state.
-pub extern "C" fn CResult_StringErrorZ_err(e: crate::c_types::Secp256k1Error) -> CResult_StringErrorZ {
-       CResult_StringErrorZ {
-               contents: CResult_StringErrorZPtr {
+/// Creates a new CResult_InitFeaturesDecodeErrorZ in the error state.
+pub extern "C" fn CResult_InitFeaturesDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_InitFeaturesDecodeErrorZ {
+       CResult_InitFeaturesDecodeErrorZ {
+               contents: CResult_InitFeaturesDecodeErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_StringErrorZ.
-pub extern "C" fn CResult_StringErrorZ_free(_res: CResult_StringErrorZ) { }
-impl Drop for CResult_StringErrorZ {
+/// Frees any resources used by the CResult_InitFeaturesDecodeErrorZ.
+pub extern "C" fn CResult_InitFeaturesDecodeErrorZ_free(_res: CResult_InitFeaturesDecodeErrorZ) { }
+impl Drop for CResult_InitFeaturesDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -2506,16 +2338,16 @@ impl Drop for CResult_StringErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::c_types::Str, crate::c_types::Secp256k1Error>> for CResult_StringErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::c_types::Str, crate::c_types::Secp256k1Error>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::ln::features::InitFeatures, crate::lightning::ln::msgs::DecodeError>> for CResult_InitFeaturesDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::features::InitFeatures, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_StringErrorZPtr { result }
+                       CResult_InitFeaturesDecodeErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_StringErrorZPtr { err }
+                       CResult_InitFeaturesDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -2524,50 +2356,50 @@ impl From<crate::c_types::CResultTempl<crate::c_types::Str, crate::c_types::Secp
        }
 }
 #[repr(C)]
-/// The contents of CResult_ChannelMonitorUpdateDecodeErrorZ
-pub union CResult_ChannelMonitorUpdateDecodeErrorZPtr {
+/// The contents of CResult_NodeFeaturesDecodeErrorZ
+pub union CResult_NodeFeaturesDecodeErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::chain::channelmonitor::ChannelMonitorUpdate,
+       pub result: *mut crate::lightning::ln::features::NodeFeatures,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
        pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// 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.
+/// 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`.
-pub struct CResult_ChannelMonitorUpdateDecodeErrorZ {
-       /// The contents of this CResult_ChannelMonitorUpdateDecodeErrorZ, accessible via either
+pub struct CResult_NodeFeaturesDecodeErrorZ {
+       /// The contents of this CResult_NodeFeaturesDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_ChannelMonitorUpdateDecodeErrorZPtr,
-       /// Whether this CResult_ChannelMonitorUpdateDecodeErrorZ represents a success state.
+       pub contents: CResult_NodeFeaturesDecodeErrorZPtr,
+       /// Whether this CResult_NodeFeaturesDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_ChannelMonitorUpdateDecodeErrorZ in the success state.
-pub extern "C" fn CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o: crate::lightning::chain::channelmonitor::ChannelMonitorUpdate) -> CResult_ChannelMonitorUpdateDecodeErrorZ {
-       CResult_ChannelMonitorUpdateDecodeErrorZ {
-               contents: CResult_ChannelMonitorUpdateDecodeErrorZPtr {
+/// Creates a new CResult_NodeFeaturesDecodeErrorZ in the success state.
+pub extern "C" fn CResult_NodeFeaturesDecodeErrorZ_ok(o: crate::lightning::ln::features::NodeFeatures) -> CResult_NodeFeaturesDecodeErrorZ {
+       CResult_NodeFeaturesDecodeErrorZ {
+               contents: CResult_NodeFeaturesDecodeErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_ChannelMonitorUpdateDecodeErrorZ in the error state.
-pub extern "C" fn CResult_ChannelMonitorUpdateDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_ChannelMonitorUpdateDecodeErrorZ {
-       CResult_ChannelMonitorUpdateDecodeErrorZ {
-               contents: CResult_ChannelMonitorUpdateDecodeErrorZPtr {
+/// Creates a new CResult_NodeFeaturesDecodeErrorZ in the error state.
+pub extern "C" fn CResult_NodeFeaturesDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_NodeFeaturesDecodeErrorZ {
+       CResult_NodeFeaturesDecodeErrorZ {
+               contents: CResult_NodeFeaturesDecodeErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_ChannelMonitorUpdateDecodeErrorZ.
-pub extern "C" fn CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res: CResult_ChannelMonitorUpdateDecodeErrorZ) { }
-impl Drop for CResult_ChannelMonitorUpdateDecodeErrorZ {
+/// Frees any resources used by the CResult_NodeFeaturesDecodeErrorZ.
+pub extern "C" fn CResult_NodeFeaturesDecodeErrorZ_free(_res: CResult_NodeFeaturesDecodeErrorZ) { }
+impl Drop for CResult_NodeFeaturesDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -2580,16 +2412,16 @@ impl Drop for CResult_ChannelMonitorUpdateDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::chain::channelmonitor::ChannelMonitorUpdate, crate::lightning::ln::msgs::DecodeError>> for CResult_ChannelMonitorUpdateDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::chain::channelmonitor::ChannelMonitorUpdate, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::ln::features::NodeFeatures, crate::lightning::ln::msgs::DecodeError>> for CResult_NodeFeaturesDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::features::NodeFeatures, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_ChannelMonitorUpdateDecodeErrorZPtr { result }
+                       CResult_NodeFeaturesDecodeErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_ChannelMonitorUpdateDecodeErrorZPtr { err }
+                       CResult_NodeFeaturesDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -2597,68 +2429,51 @@ impl From<crate::c_types::CResultTempl<crate::lightning::chain::channelmonitor::
                }
        }
 }
-impl Clone for CResult_ChannelMonitorUpdateDecodeErrorZ {
-       fn clone(&self) -> Self {
-               if self.result_ok {
-                       Self { result_ok: true, contents: CResult_ChannelMonitorUpdateDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::chain::channelmonitor::ChannelMonitorUpdate>::clone(unsafe { &*self.contents.result })))
-                       } }
-               } else {
-                       Self { result_ok: false, contents: CResult_ChannelMonitorUpdateDecodeErrorZPtr {
-                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
-                       } }
-               }
-       }
-}
-#[no_mangle]
-/// Creates a new CResult_ChannelMonitorUpdateDecodeErrorZ which has the same data as `orig`
-/// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig: &CResult_ChannelMonitorUpdateDecodeErrorZ) -> CResult_ChannelMonitorUpdateDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_HTLCUpdateDecodeErrorZ
-pub union CResult_HTLCUpdateDecodeErrorZPtr {
+/// The contents of CResult_ChannelFeaturesDecodeErrorZ
+pub union CResult_ChannelFeaturesDecodeErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::chain::channelmonitor::HTLCUpdate,
+       pub result: *mut crate::lightning::ln::features::ChannelFeatures,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
        pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// 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.
+/// 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`.
-pub struct CResult_HTLCUpdateDecodeErrorZ {
-       /// The contents of this CResult_HTLCUpdateDecodeErrorZ, accessible via either
+pub struct CResult_ChannelFeaturesDecodeErrorZ {
+       /// The contents of this CResult_ChannelFeaturesDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_HTLCUpdateDecodeErrorZPtr,
-       /// Whether this CResult_HTLCUpdateDecodeErrorZ represents a success state.
+       pub contents: CResult_ChannelFeaturesDecodeErrorZPtr,
+       /// Whether this CResult_ChannelFeaturesDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_HTLCUpdateDecodeErrorZ in the success state.
-pub extern "C" fn CResult_HTLCUpdateDecodeErrorZ_ok(o: crate::lightning::chain::channelmonitor::HTLCUpdate) -> CResult_HTLCUpdateDecodeErrorZ {
-       CResult_HTLCUpdateDecodeErrorZ {
-               contents: CResult_HTLCUpdateDecodeErrorZPtr {
+/// Creates a new CResult_ChannelFeaturesDecodeErrorZ in the success state.
+pub extern "C" fn CResult_ChannelFeaturesDecodeErrorZ_ok(o: crate::lightning::ln::features::ChannelFeatures) -> CResult_ChannelFeaturesDecodeErrorZ {
+       CResult_ChannelFeaturesDecodeErrorZ {
+               contents: CResult_ChannelFeaturesDecodeErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_HTLCUpdateDecodeErrorZ in the error state.
-pub extern "C" fn CResult_HTLCUpdateDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_HTLCUpdateDecodeErrorZ {
-       CResult_HTLCUpdateDecodeErrorZ {
-               contents: CResult_HTLCUpdateDecodeErrorZPtr {
+/// Creates a new CResult_ChannelFeaturesDecodeErrorZ in the error state.
+pub extern "C" fn CResult_ChannelFeaturesDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_ChannelFeaturesDecodeErrorZ {
+       CResult_ChannelFeaturesDecodeErrorZ {
+               contents: CResult_ChannelFeaturesDecodeErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_HTLCUpdateDecodeErrorZ.
-pub extern "C" fn CResult_HTLCUpdateDecodeErrorZ_free(_res: CResult_HTLCUpdateDecodeErrorZ) { }
-impl Drop for CResult_HTLCUpdateDecodeErrorZ {
+/// Frees any resources used by the CResult_ChannelFeaturesDecodeErrorZ.
+pub extern "C" fn CResult_ChannelFeaturesDecodeErrorZ_free(_res: CResult_ChannelFeaturesDecodeErrorZ) { }
+impl Drop for CResult_ChannelFeaturesDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -2671,16 +2486,16 @@ impl Drop for CResult_HTLCUpdateDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::chain::channelmonitor::HTLCUpdate, crate::lightning::ln::msgs::DecodeError>> for CResult_HTLCUpdateDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::chain::channelmonitor::HTLCUpdate, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::ln::features::ChannelFeatures, crate::lightning::ln::msgs::DecodeError>> for CResult_ChannelFeaturesDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::features::ChannelFeatures, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_HTLCUpdateDecodeErrorZPtr { result }
+                       CResult_ChannelFeaturesDecodeErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_HTLCUpdateDecodeErrorZPtr { err }
+                       CResult_ChannelFeaturesDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -2688,69 +2503,130 @@ impl From<crate::c_types::CResultTempl<crate::lightning::chain::channelmonitor::
                }
        }
 }
-impl Clone for CResult_HTLCUpdateDecodeErrorZ {
-       fn clone(&self) -> Self {
+#[repr(C)]
+/// The contents of CResult_InvoiceFeaturesDecodeErrorZ
+pub union CResult_InvoiceFeaturesDecodeErrorZPtr {
+       /// A pointer to the contents in the success state.
+       /// Reading from this pointer when `result_ok` is not set is undefined.
+       pub result: *mut crate::lightning::ln::features::InvoiceFeatures,
+       /// A pointer to the contents in the error state.
+       /// Reading from this pointer when `result_ok` is set is undefined.
+       pub err: *mut crate::lightning::ln::msgs::DecodeError,
+}
+#[repr(C)]
+/// 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`.
+pub struct CResult_InvoiceFeaturesDecodeErrorZ {
+       /// The contents of this CResult_InvoiceFeaturesDecodeErrorZ, accessible via either
+       /// `err` or `result` depending on the state of `result_ok`.
+       pub contents: CResult_InvoiceFeaturesDecodeErrorZPtr,
+       /// Whether this CResult_InvoiceFeaturesDecodeErrorZ represents a success state.
+       pub result_ok: bool,
+}
+#[no_mangle]
+/// Creates a new CResult_InvoiceFeaturesDecodeErrorZ in the success state.
+pub extern "C" fn CResult_InvoiceFeaturesDecodeErrorZ_ok(o: crate::lightning::ln::features::InvoiceFeatures) -> CResult_InvoiceFeaturesDecodeErrorZ {
+       CResult_InvoiceFeaturesDecodeErrorZ {
+               contents: CResult_InvoiceFeaturesDecodeErrorZPtr {
+                       result: Box::into_raw(Box::new(o)),
+               },
+               result_ok: true,
+       }
+}
+#[no_mangle]
+/// Creates a new CResult_InvoiceFeaturesDecodeErrorZ in the error state.
+pub extern "C" fn CResult_InvoiceFeaturesDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_InvoiceFeaturesDecodeErrorZ {
+       CResult_InvoiceFeaturesDecodeErrorZ {
+               contents: CResult_InvoiceFeaturesDecodeErrorZPtr {
+                       err: Box::into_raw(Box::new(e)),
+               },
+               result_ok: false,
+       }
+}
+#[no_mangle]
+/// Frees any resources used by the CResult_InvoiceFeaturesDecodeErrorZ.
+pub extern "C" fn CResult_InvoiceFeaturesDecodeErrorZ_free(_res: CResult_InvoiceFeaturesDecodeErrorZ) { }
+impl Drop for CResult_InvoiceFeaturesDecodeErrorZ {
+       fn drop(&mut self) {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_HTLCUpdateDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::chain::channelmonitor::HTLCUpdate>::clone(unsafe { &*self.contents.result })))
-                       } }
+                       if unsafe { !(self.contents.result as *mut ()).is_null() } {
+                               let _ = unsafe { Box::from_raw(self.contents.result) };
+                       }
                } else {
-                       Self { result_ok: false, contents: CResult_HTLCUpdateDecodeErrorZPtr {
-                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
-                       } }
+                       if unsafe { !(self.contents.err as *mut ()).is_null() } {
+                               let _ = unsafe { Box::from_raw(self.contents.err) };
+                       }
+               }
+       }
+}
+impl From<crate::c_types::CResultTempl<crate::lightning::ln::features::InvoiceFeatures, crate::lightning::ln::msgs::DecodeError>> for CResult_InvoiceFeaturesDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::features::InvoiceFeatures, crate::lightning::ln::msgs::DecodeError>) -> Self {
+               let contents = if o.result_ok {
+                       let result = unsafe { o.contents.result };
+                       unsafe { o.contents.result = std::ptr::null_mut() };
+                       CResult_InvoiceFeaturesDecodeErrorZPtr { result }
+               } else {
+                       let err = unsafe { o.contents.err };
+                       unsafe { o.contents.err = std::ptr::null_mut(); }
+                       CResult_InvoiceFeaturesDecodeErrorZPtr { err }
+               };
+               Self {
+                       contents,
+                       result_ok: o.result_ok,
                }
        }
 }
-#[no_mangle]
-/// Creates a new CResult_HTLCUpdateDecodeErrorZ which has the same data as `orig`
-/// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_HTLCUpdateDecodeErrorZ_clone(orig: &CResult_HTLCUpdateDecodeErrorZ) -> CResult_HTLCUpdateDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_NoneMonitorUpdateErrorZ
-pub union CResult_NoneMonitorUpdateErrorZPtr {
-       /// Note that this value is always NULL, as there are no contents in the OK variant
-       pub result: *mut std::ffi::c_void,
+/// The contents of CResult_DelayedPaymentOutputDescriptorDecodeErrorZ
+pub union CResult_DelayedPaymentOutputDescriptorDecodeErrorZPtr {
+       /// A pointer to the contents in the success state.
+       /// Reading from this pointer when `result_ok` is not set is undefined.
+       pub result: *mut crate::lightning::chain::keysinterface::DelayedPaymentOutputDescriptor,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::lightning::chain::channelmonitor::MonitorUpdateError,
+       pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// A CResult_NoneMonitorUpdateErrorZ represents the result of a fallible operation,
-/// containing a () on success and a crate::lightning::chain::channelmonitor::MonitorUpdateError on failure.
+/// A CResult_DelayedPaymentOutputDescriptorDecodeErrorZ represents the result of a fallible operation,
+/// containing a crate::lightning::chain::keysinterface::DelayedPaymentOutputDescriptor on success and a crate::lightning::ln::msgs::DecodeError on failure.
 /// `result_ok` indicates the overall state, and the contents are provided via `contents`.
-pub struct CResult_NoneMonitorUpdateErrorZ {
-       /// The contents of this CResult_NoneMonitorUpdateErrorZ, accessible via either
+pub struct CResult_DelayedPaymentOutputDescriptorDecodeErrorZ {
+       /// The contents of this CResult_DelayedPaymentOutputDescriptorDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_NoneMonitorUpdateErrorZPtr,
-       /// Whether this CResult_NoneMonitorUpdateErrorZ represents a success state.
+       pub contents: CResult_DelayedPaymentOutputDescriptorDecodeErrorZPtr,
+       /// Whether this CResult_DelayedPaymentOutputDescriptorDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_NoneMonitorUpdateErrorZ in the success state.
-pub extern "C" fn CResult_NoneMonitorUpdateErrorZ_ok() -> CResult_NoneMonitorUpdateErrorZ {
-       CResult_NoneMonitorUpdateErrorZ {
-               contents: CResult_NoneMonitorUpdateErrorZPtr {
-                       result: std::ptr::null_mut(),
+/// Creates a new CResult_DelayedPaymentOutputDescriptorDecodeErrorZ in the success state.
+pub extern "C" fn CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o: crate::lightning::chain::keysinterface::DelayedPaymentOutputDescriptor) -> CResult_DelayedPaymentOutputDescriptorDecodeErrorZ {
+       CResult_DelayedPaymentOutputDescriptorDecodeErrorZ {
+               contents: CResult_DelayedPaymentOutputDescriptorDecodeErrorZPtr {
+                       result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_NoneMonitorUpdateErrorZ in the error state.
-pub extern "C" fn CResult_NoneMonitorUpdateErrorZ_err(e: crate::lightning::chain::channelmonitor::MonitorUpdateError) -> CResult_NoneMonitorUpdateErrorZ {
-       CResult_NoneMonitorUpdateErrorZ {
-               contents: CResult_NoneMonitorUpdateErrorZPtr {
+/// Creates a new CResult_DelayedPaymentOutputDescriptorDecodeErrorZ in the error state.
+pub extern "C" fn CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_DelayedPaymentOutputDescriptorDecodeErrorZ {
+       CResult_DelayedPaymentOutputDescriptorDecodeErrorZ {
+               contents: CResult_DelayedPaymentOutputDescriptorDecodeErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_NoneMonitorUpdateErrorZ.
-pub extern "C" fn CResult_NoneMonitorUpdateErrorZ_free(_res: CResult_NoneMonitorUpdateErrorZ) { }
-impl Drop for CResult_NoneMonitorUpdateErrorZ {
+/// Frees any resources used by the CResult_DelayedPaymentOutputDescriptorDecodeErrorZ.
+pub extern "C" fn CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res: CResult_DelayedPaymentOutputDescriptorDecodeErrorZ) { }
+impl Drop for CResult_DelayedPaymentOutputDescriptorDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
+                       if unsafe { !(self.contents.result as *mut ()).is_null() } {
+                               let _ = unsafe { Box::from_raw(self.contents.result) };
+                       }
                } else {
                        if unsafe { !(self.contents.err as *mut ()).is_null() } {
                                let _ = unsafe { Box::from_raw(self.contents.err) };
@@ -2758,16 +2634,16 @@ impl Drop for CResult_NoneMonitorUpdateErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<(), crate::lightning::chain::channelmonitor::MonitorUpdateError>> for CResult_NoneMonitorUpdateErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<(), crate::lightning::chain::channelmonitor::MonitorUpdateError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::chain::keysinterface::DelayedPaymentOutputDescriptor, crate::lightning::ln::msgs::DecodeError>> for CResult_DelayedPaymentOutputDescriptorDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::chain::keysinterface::DelayedPaymentOutputDescriptor, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
-                       let _ = unsafe { Box::from_raw(o.contents.result) };
-                       o.contents.result = std::ptr::null_mut();
-                       CResult_NoneMonitorUpdateErrorZPtr { result: std::ptr::null_mut() }
+                       let result = unsafe { o.contents.result };
+                       unsafe { o.contents.result = std::ptr::null_mut() };
+                       CResult_DelayedPaymentOutputDescriptorDecodeErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_NoneMonitorUpdateErrorZPtr { err }
+                       CResult_DelayedPaymentOutputDescriptorDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -2775,561 +2651,536 @@ impl From<crate::c_types::CResultTempl<(), crate::lightning::chain::channelmonit
                }
        }
 }
-impl Clone for CResult_NoneMonitorUpdateErrorZ {
+impl Clone for CResult_DelayedPaymentOutputDescriptorDecodeErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_NoneMonitorUpdateErrorZPtr {
-                               result: std::ptr::null_mut()
+                       Self { result_ok: true, contents: CResult_DelayedPaymentOutputDescriptorDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::chain::keysinterface::DelayedPaymentOutputDescriptor>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_NoneMonitorUpdateErrorZPtr {
-                               err: Box::into_raw(Box::new(<crate::lightning::chain::channelmonitor::MonitorUpdateError>::clone(unsafe { &*self.contents.err })))
+                       Self { result_ok: false, contents: CResult_DelayedPaymentOutputDescriptorDecodeErrorZPtr {
+                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_NoneMonitorUpdateErrorZ which has the same data as `orig`
+/// Creates a new CResult_DelayedPaymentOutputDescriptorDecodeErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_NoneMonitorUpdateErrorZ_clone(orig: &CResult_NoneMonitorUpdateErrorZ) -> CResult_NoneMonitorUpdateErrorZ { orig.clone() }
+pub extern "C" fn CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig: &CResult_DelayedPaymentOutputDescriptorDecodeErrorZ) -> CResult_DelayedPaymentOutputDescriptorDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// A tuple of 2 elements. See the individual fields for the types contained.
-pub struct C2Tuple_OutPointScriptZ {
-       /// The element at position 0
-       pub a: crate::lightning::chain::transaction::OutPoint,
-       /// The element at position 1
-       pub b: crate::c_types::derived::CVec_u8Z,
+/// The contents of CResult_StaticPaymentOutputDescriptorDecodeErrorZ
+pub union CResult_StaticPaymentOutputDescriptorDecodeErrorZPtr {
+       /// A pointer to the contents in the success state.
+       /// Reading from this pointer when `result_ok` is not set is undefined.
+       pub result: *mut crate::lightning::chain::keysinterface::StaticPaymentOutputDescriptor,
+       /// A pointer to the contents in the error state.
+       /// Reading from this pointer when `result_ok` is set is undefined.
+       pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
-impl From<(crate::lightning::chain::transaction::OutPoint, crate::c_types::derived::CVec_u8Z)> for C2Tuple_OutPointScriptZ {
-       fn from (tup: (crate::lightning::chain::transaction::OutPoint, crate::c_types::derived::CVec_u8Z)) -> Self {
-               Self {
-                       a: tup.0,
-                       b: tup.1,
-               }
+#[repr(C)]
+/// A CResult_StaticPaymentOutputDescriptorDecodeErrorZ represents the result of a fallible operation,
+/// containing a crate::lightning::chain::keysinterface::StaticPaymentOutputDescriptor on success and a crate::lightning::ln::msgs::DecodeError on failure.
+/// `result_ok` indicates the overall state, and the contents are provided via `contents`.
+pub struct CResult_StaticPaymentOutputDescriptorDecodeErrorZ {
+       /// The contents of this CResult_StaticPaymentOutputDescriptorDecodeErrorZ, accessible via either
+       /// `err` or `result` depending on the state of `result_ok`.
+       pub contents: CResult_StaticPaymentOutputDescriptorDecodeErrorZPtr,
+       /// Whether this CResult_StaticPaymentOutputDescriptorDecodeErrorZ represents a success state.
+       pub result_ok: bool,
+}
+#[no_mangle]
+/// Creates a new CResult_StaticPaymentOutputDescriptorDecodeErrorZ in the success state.
+pub extern "C" fn CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o: crate::lightning::chain::keysinterface::StaticPaymentOutputDescriptor) -> CResult_StaticPaymentOutputDescriptorDecodeErrorZ {
+       CResult_StaticPaymentOutputDescriptorDecodeErrorZ {
+               contents: CResult_StaticPaymentOutputDescriptorDecodeErrorZPtr {
+                       result: Box::into_raw(Box::new(o)),
+               },
+               result_ok: true,
        }
 }
-impl C2Tuple_OutPointScriptZ {
-       #[allow(unused)] pub(crate) fn to_rust(mut self) -> (crate::lightning::chain::transaction::OutPoint, crate::c_types::derived::CVec_u8Z) {
-               (self.a, self.b)
+#[no_mangle]
+/// Creates a new CResult_StaticPaymentOutputDescriptorDecodeErrorZ in the error state.
+pub extern "C" fn CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_StaticPaymentOutputDescriptorDecodeErrorZ {
+       CResult_StaticPaymentOutputDescriptorDecodeErrorZ {
+               contents: CResult_StaticPaymentOutputDescriptorDecodeErrorZPtr {
+                       err: Box::into_raw(Box::new(e)),
+               },
+               result_ok: false,
        }
 }
-impl Clone for C2Tuple_OutPointScriptZ {
-       fn clone(&self) -> Self {
-               Self {
-                       a: self.a.clone(),
-                       b: self.b.clone(),
+#[no_mangle]
+/// Frees any resources used by the CResult_StaticPaymentOutputDescriptorDecodeErrorZ.
+pub extern "C" fn CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res: CResult_StaticPaymentOutputDescriptorDecodeErrorZ) { }
+impl Drop for CResult_StaticPaymentOutputDescriptorDecodeErrorZ {
+       fn drop(&mut self) {
+               if self.result_ok {
+                       if unsafe { !(self.contents.result as *mut ()).is_null() } {
+                               let _ = unsafe { Box::from_raw(self.contents.result) };
+                       }
+               } else {
+                       if unsafe { !(self.contents.err as *mut ()).is_null() } {
+                               let _ = unsafe { Box::from_raw(self.contents.err) };
+                       }
                }
        }
 }
-#[no_mangle]
-/// Creates a new tuple which has the same data as `orig`
-/// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn C2Tuple_OutPointScriptZ_clone(orig: &C2Tuple_OutPointScriptZ) -> C2Tuple_OutPointScriptZ { orig.clone() }
-/// Creates a new C2Tuple_OutPointScriptZ from the contained elements.
-#[no_mangle]
-pub extern "C" fn C2Tuple_OutPointScriptZ_new(a: crate::lightning::chain::transaction::OutPoint, b: crate::c_types::derived::CVec_u8Z) -> C2Tuple_OutPointScriptZ {
-       C2Tuple_OutPointScriptZ { a, b, }
-}
-
-#[no_mangle]
-/// Frees any resources used by the C2Tuple_OutPointScriptZ.
-pub extern "C" fn C2Tuple_OutPointScriptZ_free(_res: C2Tuple_OutPointScriptZ) { }
-#[repr(C)]
-/// A tuple of 2 elements. See the individual fields for the types contained.
-pub struct C2Tuple_u32ScriptZ {
-       /// The element at position 0
-       pub a: u32,
-       /// The element at position 1
-       pub b: crate::c_types::derived::CVec_u8Z,
-}
-impl From<(u32, crate::c_types::derived::CVec_u8Z)> for C2Tuple_u32ScriptZ {
-       fn from (tup: (u32, crate::c_types::derived::CVec_u8Z)) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::chain::keysinterface::StaticPaymentOutputDescriptor, crate::lightning::ln::msgs::DecodeError>> for CResult_StaticPaymentOutputDescriptorDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::chain::keysinterface::StaticPaymentOutputDescriptor, crate::lightning::ln::msgs::DecodeError>) -> Self {
+               let contents = if o.result_ok {
+                       let result = unsafe { o.contents.result };
+                       unsafe { o.contents.result = std::ptr::null_mut() };
+                       CResult_StaticPaymentOutputDescriptorDecodeErrorZPtr { result }
+               } else {
+                       let err = unsafe { o.contents.err };
+                       unsafe { o.contents.err = std::ptr::null_mut(); }
+                       CResult_StaticPaymentOutputDescriptorDecodeErrorZPtr { err }
+               };
                Self {
-                       a: tup.0,
-                       b: tup.1,
+                       contents,
+                       result_ok: o.result_ok,
                }
        }
 }
-impl C2Tuple_u32ScriptZ {
-       #[allow(unused)] pub(crate) fn to_rust(mut self) -> (u32, crate::c_types::derived::CVec_u8Z) {
-               (self.a, self.b)
-       }
-}
-impl Clone for C2Tuple_u32ScriptZ {
+impl Clone for CResult_StaticPaymentOutputDescriptorDecodeErrorZ {
        fn clone(&self) -> Self {
-               Self {
-                       a: self.a.clone(),
-                       b: self.b.clone(),
+               if self.result_ok {
+                       Self { result_ok: true, contents: CResult_StaticPaymentOutputDescriptorDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::chain::keysinterface::StaticPaymentOutputDescriptor>::clone(unsafe { &*self.contents.result })))
+                       } }
+               } else {
+                       Self { result_ok: false, contents: CResult_StaticPaymentOutputDescriptorDecodeErrorZPtr {
+                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
+                       } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new tuple which has the same data as `orig`
+/// Creates a new CResult_StaticPaymentOutputDescriptorDecodeErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn C2Tuple_u32ScriptZ_clone(orig: &C2Tuple_u32ScriptZ) -> C2Tuple_u32ScriptZ { orig.clone() }
-/// Creates a new C2Tuple_u32ScriptZ from the contained elements.
-#[no_mangle]
-pub extern "C" fn C2Tuple_u32ScriptZ_new(a: u32, b: crate::c_types::derived::CVec_u8Z) -> C2Tuple_u32ScriptZ {
-       C2Tuple_u32ScriptZ { a, b, }
+pub extern "C" fn CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig: &CResult_StaticPaymentOutputDescriptorDecodeErrorZ) -> CResult_StaticPaymentOutputDescriptorDecodeErrorZ { orig.clone() }
+#[repr(C)]
+/// The contents of CResult_SpendableOutputDescriptorDecodeErrorZ
+pub union CResult_SpendableOutputDescriptorDecodeErrorZPtr {
+       /// A pointer to the contents in the success state.
+       /// Reading from this pointer when `result_ok` is not set is undefined.
+       pub result: *mut crate::lightning::chain::keysinterface::SpendableOutputDescriptor,
+       /// A pointer to the contents in the error state.
+       /// Reading from this pointer when `result_ok` is set is undefined.
+       pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
-
-#[no_mangle]
-/// Frees any resources used by the C2Tuple_u32ScriptZ.
-pub extern "C" fn C2Tuple_u32ScriptZ_free(_res: C2Tuple_u32ScriptZ) { }
 #[repr(C)]
-/// A dynamically-allocated array of crate::c_types::derived::C2Tuple_u32ScriptZs of arbitrary size.
-/// This corresponds to std::vector in C++
-pub struct CVec_C2Tuple_u32ScriptZZ {
-       /// The elements in the array.
-       /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
-       pub data: *mut crate::c_types::derived::C2Tuple_u32ScriptZ,
-       /// The number of elements pointed to by `data`.
-       pub datalen: usize
+/// 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`.
+pub struct CResult_SpendableOutputDescriptorDecodeErrorZ {
+       /// The contents of this CResult_SpendableOutputDescriptorDecodeErrorZ, accessible via either
+       /// `err` or `result` depending on the state of `result_ok`.
+       pub contents: CResult_SpendableOutputDescriptorDecodeErrorZPtr,
+       /// Whether this CResult_SpendableOutputDescriptorDecodeErrorZ represents a success state.
+       pub result_ok: bool,
 }
-impl CVec_C2Tuple_u32ScriptZZ {
-       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::c_types::derived::C2Tuple_u32ScriptZ> {
-               if self.datalen == 0 { return Vec::new(); }
-               let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
-               self.data = std::ptr::null_mut();
-               self.datalen = 0;
-               ret
-       }
-       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::c_types::derived::C2Tuple_u32ScriptZ] {
-               unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
+#[no_mangle]
+/// Creates a new CResult_SpendableOutputDescriptorDecodeErrorZ in the success state.
+pub extern "C" fn CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o: crate::lightning::chain::keysinterface::SpendableOutputDescriptor) -> CResult_SpendableOutputDescriptorDecodeErrorZ {
+       CResult_SpendableOutputDescriptorDecodeErrorZ {
+               contents: CResult_SpendableOutputDescriptorDecodeErrorZPtr {
+                       result: Box::into_raw(Box::new(o)),
+               },
+               result_ok: true,
        }
 }
-impl From<Vec<crate::c_types::derived::C2Tuple_u32ScriptZ>> for CVec_C2Tuple_u32ScriptZZ {
-       fn from(v: Vec<crate::c_types::derived::C2Tuple_u32ScriptZ>) -> Self {
-               let datalen = v.len();
-               let data = Box::into_raw(v.into_boxed_slice());
-               Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
+#[no_mangle]
+/// Creates a new CResult_SpendableOutputDescriptorDecodeErrorZ in the error state.
+pub extern "C" fn CResult_SpendableOutputDescriptorDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_SpendableOutputDescriptorDecodeErrorZ {
+       CResult_SpendableOutputDescriptorDecodeErrorZ {
+               contents: CResult_SpendableOutputDescriptorDecodeErrorZPtr {
+                       err: Box::into_raw(Box::new(e)),
+               },
+               result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees the buffer pointed to by `data` if `datalen` is non-0.
-pub extern "C" fn CVec_C2Tuple_u32ScriptZZ_free(_res: CVec_C2Tuple_u32ScriptZZ) { }
-impl Drop for CVec_C2Tuple_u32ScriptZZ {
+/// Frees any resources used by the CResult_SpendableOutputDescriptorDecodeErrorZ.
+pub extern "C" fn CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res: CResult_SpendableOutputDescriptorDecodeErrorZ) { }
+impl Drop for CResult_SpendableOutputDescriptorDecodeErrorZ {
        fn drop(&mut self) {
-               if self.datalen == 0 { return; }
-               unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
+               if self.result_ok {
+                       if unsafe { !(self.contents.result as *mut ()).is_null() } {
+                               let _ = unsafe { Box::from_raw(self.contents.result) };
+                       }
+               } else {
+                       if unsafe { !(self.contents.err as *mut ()).is_null() } {
+                               let _ = unsafe { Box::from_raw(self.contents.err) };
+                       }
+               }
        }
 }
-impl Clone for CVec_C2Tuple_u32ScriptZZ {
+impl From<crate::c_types::CResultTempl<crate::lightning::chain::keysinterface::SpendableOutputDescriptor, crate::lightning::ln::msgs::DecodeError>> for CResult_SpendableOutputDescriptorDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::chain::keysinterface::SpendableOutputDescriptor, crate::lightning::ln::msgs::DecodeError>) -> Self {
+               let contents = if o.result_ok {
+                       let result = unsafe { o.contents.result };
+                       unsafe { o.contents.result = std::ptr::null_mut() };
+                       CResult_SpendableOutputDescriptorDecodeErrorZPtr { result }
+               } else {
+                       let err = unsafe { o.contents.err };
+                       unsafe { o.contents.err = std::ptr::null_mut(); }
+                       CResult_SpendableOutputDescriptorDecodeErrorZPtr { err }
+               };
+               Self {
+                       contents,
+                       result_ok: o.result_ok,
+               }
+       }
+}
+impl Clone for CResult_SpendableOutputDescriptorDecodeErrorZ {
        fn clone(&self) -> Self {
-               let mut res = Vec::new();
-               if self.datalen == 0 { return Self::from(res); }
-               res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
-               Self::from(res)
+               if self.result_ok {
+                       Self { result_ok: true, contents: CResult_SpendableOutputDescriptorDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::chain::keysinterface::SpendableOutputDescriptor>::clone(unsafe { &*self.contents.result })))
+                       } }
+               } else {
+                       Self { result_ok: false, contents: CResult_SpendableOutputDescriptorDecodeErrorZPtr {
+                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
+                       } }
+               }
        }
 }
+#[no_mangle]
+/// Creates a new CResult_SpendableOutputDescriptorDecodeErrorZ which has the same data as `orig`
+/// but with all dynamically-allocated buffers duplicated in new buffers.
+pub extern "C" fn CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig: &CResult_SpendableOutputDescriptorDecodeErrorZ) -> CResult_SpendableOutputDescriptorDecodeErrorZ { orig.clone() }
 #[repr(C)]
 /// A tuple of 2 elements. See the individual fields for the types contained.
-pub struct C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ {
+pub struct C2Tuple_SignatureCVec_SignatureZZ {
        /// The element at position 0
-       pub a: crate::c_types::ThirtyTwoBytes,
+       pub a: crate::c_types::Signature,
        /// The element at position 1
-       pub b: crate::c_types::derived::CVec_C2Tuple_u32ScriptZZ,
+       pub b: crate::c_types::derived::CVec_SignatureZ,
 }
-impl From<(crate::c_types::ThirtyTwoBytes, crate::c_types::derived::CVec_C2Tuple_u32ScriptZZ)> for C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ {
-       fn from (tup: (crate::c_types::ThirtyTwoBytes, crate::c_types::derived::CVec_C2Tuple_u32ScriptZZ)) -> Self {
+impl From<(crate::c_types::Signature, crate::c_types::derived::CVec_SignatureZ)> for C2Tuple_SignatureCVec_SignatureZZ {
+       fn from (tup: (crate::c_types::Signature, crate::c_types::derived::CVec_SignatureZ)) -> Self {
                Self {
                        a: tup.0,
                        b: tup.1,
                }
        }
 }
-impl C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ {
-       #[allow(unused)] pub(crate) fn to_rust(mut self) -> (crate::c_types::ThirtyTwoBytes, crate::c_types::derived::CVec_C2Tuple_u32ScriptZZ) {
+impl C2Tuple_SignatureCVec_SignatureZZ {
+       #[allow(unused)] pub(crate) fn to_rust(mut self) -> (crate::c_types::Signature, crate::c_types::derived::CVec_SignatureZ) {
                (self.a, self.b)
        }
 }
-/// Creates a new C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ from the contained elements.
+impl Clone for C2Tuple_SignatureCVec_SignatureZZ {
+       fn clone(&self) -> Self {
+               Self {
+                       a: self.a.clone(),
+                       b: self.b.clone(),
+               }
+       }
+}
 #[no_mangle]
-pub extern "C" fn C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a: crate::c_types::ThirtyTwoBytes, b: crate::c_types::derived::CVec_C2Tuple_u32ScriptZZ) -> C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ {
-       C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ { a, b, }
+/// Creates a new tuple which has the same data as `orig`
+/// but with all dynamically-allocated buffers duplicated in new buffers.
+pub extern "C" fn C2Tuple_SignatureCVec_SignatureZZ_clone(orig: &C2Tuple_SignatureCVec_SignatureZZ) -> C2Tuple_SignatureCVec_SignatureZZ { orig.clone() }
+/// Creates a new C2Tuple_SignatureCVec_SignatureZZ from the contained elements.
+#[no_mangle]
+pub extern "C" fn C2Tuple_SignatureCVec_SignatureZZ_new(a: crate::c_types::Signature, b: crate::c_types::derived::CVec_SignatureZ) -> C2Tuple_SignatureCVec_SignatureZZ {
+       C2Tuple_SignatureCVec_SignatureZZ { a, b, }
 }
 
 #[no_mangle]
-/// Frees any resources used by the C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ.
-pub extern "C" fn C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res: C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ) { }
+/// Frees any resources used by the C2Tuple_SignatureCVec_SignatureZZ.
+pub extern "C" fn C2Tuple_SignatureCVec_SignatureZZ_free(_res: C2Tuple_SignatureCVec_SignatureZZ) { }
 #[repr(C)]
-/// A dynamically-allocated array of crate::c_types::derived::C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZs of arbitrary size.
-/// This corresponds to std::vector in C++
-pub struct CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ {
-       /// The elements in the array.
-       /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
-       pub data: *mut crate::c_types::derived::C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ,
-       /// The number of elements pointed to by `data`.
-       pub datalen: usize
-}
-impl CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ {
-       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::c_types::derived::C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ> {
-               if self.datalen == 0 { return Vec::new(); }
-               let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
-               self.data = std::ptr::null_mut();
-               self.datalen = 0;
-               ret
-       }
-       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::c_types::derived::C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ] {
-               unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
-       }
+/// The contents of CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ
+pub union CResult_C2Tuple_SignatureCVec_SignatureZZNoneZPtr {
+       /// A pointer to the contents in the success state.
+       /// Reading from this pointer when `result_ok` is not set is undefined.
+       pub result: *mut crate::c_types::derived::C2Tuple_SignatureCVec_SignatureZZ,
+       /// Note that this value is always NULL, as there are no contents in the Err variant
+       pub err: *mut std::ffi::c_void,
 }
-impl From<Vec<crate::c_types::derived::C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ>> for CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ {
-       fn from(v: Vec<crate::c_types::derived::C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ>) -> Self {
-               let datalen = v.len();
-               let data = Box::into_raw(v.into_boxed_slice());
-               Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
-       }
+#[repr(C)]
+/// 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`.
+pub struct CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ {
+       /// The contents of this CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ, accessible via either
+       /// `err` or `result` depending on the state of `result_ok`.
+       pub contents: CResult_C2Tuple_SignatureCVec_SignatureZZNoneZPtr,
+       /// Whether this CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ represents a success state.
+       pub result_ok: bool,
 }
 #[no_mangle]
-/// Frees the buffer pointed to by `data` if `datalen` is non-0.
-pub extern "C" fn CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res: CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ) { }
-impl Drop for CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ {
-       fn drop(&mut self) {
-               if self.datalen == 0 { return; }
-               unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
-       }
-}
-#[repr(C)]
-/// A dynamically-allocated array of crate::lightning::chain::channelmonitor::MonitorEvents of arbitrary size.
-/// This corresponds to std::vector in C++
-pub struct CVec_MonitorEventZ {
-       /// The elements in the array.
-       /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
-       pub data: *mut crate::lightning::chain::channelmonitor::MonitorEvent,
-       /// The number of elements pointed to by `data`.
-       pub datalen: usize
-}
-impl CVec_MonitorEventZ {
-       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::lightning::chain::channelmonitor::MonitorEvent> {
-               if self.datalen == 0 { return Vec::new(); }
-               let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
-               self.data = std::ptr::null_mut();
-               self.datalen = 0;
-               ret
-       }
-       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::lightning::chain::channelmonitor::MonitorEvent] {
-               unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
-       }
-}
-impl From<Vec<crate::lightning::chain::channelmonitor::MonitorEvent>> for CVec_MonitorEventZ {
-       fn from(v: Vec<crate::lightning::chain::channelmonitor::MonitorEvent>) -> Self {
-               let datalen = v.len();
-               let data = Box::into_raw(v.into_boxed_slice());
-               Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
-       }
-}
-#[no_mangle]
-/// Frees the buffer pointed to by `data` if `datalen` is non-0.
-pub extern "C" fn CVec_MonitorEventZ_free(_res: CVec_MonitorEventZ) { }
-impl Drop for CVec_MonitorEventZ {
-       fn drop(&mut self) {
-               if self.datalen == 0 { return; }
-               unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
-       }
-}
-impl Clone for CVec_MonitorEventZ {
-       fn clone(&self) -> Self {
-               let mut res = Vec::new();
-               if self.datalen == 0 { return Self::from(res); }
-               res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
-               Self::from(res)
-       }
-}
-#[repr(C)]
-/// A dynamically-allocated array of crate::lightning::util::events::Events of arbitrary size.
-/// This corresponds to std::vector in C++
-pub struct CVec_EventZ {
-       /// The elements in the array.
-       /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
-       pub data: *mut crate::lightning::util::events::Event,
-       /// The number of elements pointed to by `data`.
-       pub datalen: usize
-}
-impl CVec_EventZ {
-       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::lightning::util::events::Event> {
-               if self.datalen == 0 { return Vec::new(); }
-               let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
-               self.data = std::ptr::null_mut();
-               self.datalen = 0;
-               ret
-       }
-       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::lightning::util::events::Event] {
-               unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
-       }
-}
-impl From<Vec<crate::lightning::util::events::Event>> for CVec_EventZ {
-       fn from(v: Vec<crate::lightning::util::events::Event>) -> Self {
-               let datalen = v.len();
-               let data = Box::into_raw(v.into_boxed_slice());
-               Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
+/// Creates a new CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ in the success state.
+pub extern "C" fn CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o: crate::c_types::derived::C2Tuple_SignatureCVec_SignatureZZ) -> CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ {
+       CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ {
+               contents: CResult_C2Tuple_SignatureCVec_SignatureZZNoneZPtr {
+                       result: Box::into_raw(Box::new(o)),
+               },
+               result_ok: true,
        }
 }
 #[no_mangle]
-/// Frees the buffer pointed to by `data` if `datalen` is non-0.
-pub extern "C" fn CVec_EventZ_free(_res: CVec_EventZ) { }
-impl Drop for CVec_EventZ {
-       fn drop(&mut self) {
-               if self.datalen == 0 { return; }
-               unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
-       }
-}
-impl Clone for CVec_EventZ {
-       fn clone(&self) -> Self {
-               let mut res = Vec::new();
-               if self.datalen == 0 { return Self::from(res); }
-               res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
-               Self::from(res)
-       }
-}
-#[repr(C)]
-/// A dynamically-allocated array of crate::c_types::Transactions of arbitrary size.
-/// This corresponds to std::vector in C++
-pub struct CVec_TransactionZ {
-       /// The elements in the array.
-       /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
-       pub data: *mut crate::c_types::Transaction,
-       /// The number of elements pointed to by `data`.
-       pub datalen: usize
-}
-impl CVec_TransactionZ {
-       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::c_types::Transaction> {
-               if self.datalen == 0 { return Vec::new(); }
-               let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
-               self.data = std::ptr::null_mut();
-               self.datalen = 0;
-               ret
-       }
-       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::c_types::Transaction] {
-               unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
-       }
-}
-impl From<Vec<crate::c_types::Transaction>> for CVec_TransactionZ {
-       fn from(v: Vec<crate::c_types::Transaction>) -> Self {
-               let datalen = v.len();
-               let data = Box::into_raw(v.into_boxed_slice());
-               Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
+/// Creates a new CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ in the error state.
+pub extern "C" fn CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err() -> CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ {
+       CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ {
+               contents: CResult_C2Tuple_SignatureCVec_SignatureZZNoneZPtr {
+                       err: std::ptr::null_mut(),
+               },
+               result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees the buffer pointed to by `data` if `datalen` is non-0.
-pub extern "C" fn CVec_TransactionZ_free(_res: CVec_TransactionZ) { }
-impl Drop for CVec_TransactionZ {
+/// Frees any resources used by the CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ.
+pub extern "C" fn CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res: CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ) { }
+impl Drop for CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ {
        fn drop(&mut self) {
-               if self.datalen == 0 { return; }
-               unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
+               if self.result_ok {
+                       if unsafe { !(self.contents.result as *mut ()).is_null() } {
+                               let _ = unsafe { Box::from_raw(self.contents.result) };
+                       }
+               } else {
+               }
        }
 }
-#[repr(C)]
-/// A tuple of 2 elements. See the individual fields for the types contained.
-pub struct C2Tuple_usizeTransactionZ {
-       /// The element at position 0
-       pub a: usize,
-       /// The element at position 1
-       pub b: crate::c_types::Transaction,
-}
-impl From<(usize, crate::c_types::Transaction)> for C2Tuple_usizeTransactionZ {
-       fn from (tup: (usize, crate::c_types::Transaction)) -> Self {
+impl From<crate::c_types::CResultTempl<crate::c_types::derived::C2Tuple_SignatureCVec_SignatureZZ, ()>> for CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::c_types::derived::C2Tuple_SignatureCVec_SignatureZZ, ()>) -> Self {
+               let contents = if o.result_ok {
+                       let result = unsafe { o.contents.result };
+                       unsafe { o.contents.result = std::ptr::null_mut() };
+                       CResult_C2Tuple_SignatureCVec_SignatureZZNoneZPtr { result }
+               } else {
+                       let _ = unsafe { Box::from_raw(o.contents.err) };
+                       o.contents.err = std::ptr::null_mut();
+                       CResult_C2Tuple_SignatureCVec_SignatureZZNoneZPtr { err: std::ptr::null_mut() }
+               };
                Self {
-                       a: tup.0,
-                       b: tup.1,
+                       contents,
+                       result_ok: o.result_ok,
                }
        }
 }
-impl C2Tuple_usizeTransactionZ {
-       #[allow(unused)] pub(crate) fn to_rust(mut self) -> (usize, crate::c_types::Transaction) {
-               (self.a, self.b)
+impl Clone for CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ {
+       fn clone(&self) -> Self {
+               if self.result_ok {
+                       Self { result_ok: true, contents: CResult_C2Tuple_SignatureCVec_SignatureZZNoneZPtr {
+                               result: Box::into_raw(Box::new(<crate::c_types::derived::C2Tuple_SignatureCVec_SignatureZZ>::clone(unsafe { &*self.contents.result })))
+                       } }
+               } else {
+                       Self { result_ok: false, contents: CResult_C2Tuple_SignatureCVec_SignatureZZNoneZPtr {
+                               err: std::ptr::null_mut()
+                       } }
+               }
        }
 }
-/// Creates a new C2Tuple_usizeTransactionZ from the contained elements.
 #[no_mangle]
-pub extern "C" fn C2Tuple_usizeTransactionZ_new(a: usize, b: crate::c_types::Transaction) -> C2Tuple_usizeTransactionZ {
-       C2Tuple_usizeTransactionZ { a, b, }
+/// Creates a new CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ which has the same data as `orig`
+/// but with all dynamically-allocated buffers duplicated in new buffers.
+pub extern "C" fn CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig: &CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ) -> CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ { orig.clone() }
+#[repr(C)]
+/// The contents of CResult_SignatureNoneZ
+pub union CResult_SignatureNoneZPtr {
+       /// A pointer to the contents in the success state.
+       /// Reading from this pointer when `result_ok` is not set is undefined.
+       pub result: *mut crate::c_types::Signature,
+       /// Note that this value is always NULL, as there are no contents in the Err variant
+       pub err: *mut std::ffi::c_void,
 }
-
-#[no_mangle]
-/// Frees any resources used by the C2Tuple_usizeTransactionZ.
-pub extern "C" fn C2Tuple_usizeTransactionZ_free(_res: C2Tuple_usizeTransactionZ) { }
 #[repr(C)]
-/// A dynamically-allocated array of crate::c_types::derived::C2Tuple_usizeTransactionZs of arbitrary size.
-/// This corresponds to std::vector in C++
-pub struct CVec_C2Tuple_usizeTransactionZZ {
-       /// The elements in the array.
-       /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
-       pub data: *mut crate::c_types::derived::C2Tuple_usizeTransactionZ,
-       /// The number of elements pointed to by `data`.
-       pub datalen: usize
+/// 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`.
+pub struct CResult_SignatureNoneZ {
+       /// The contents of this CResult_SignatureNoneZ, accessible via either
+       /// `err` or `result` depending on the state of `result_ok`.
+       pub contents: CResult_SignatureNoneZPtr,
+       /// Whether this CResult_SignatureNoneZ represents a success state.
+       pub result_ok: bool,
 }
-impl CVec_C2Tuple_usizeTransactionZZ {
-       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::c_types::derived::C2Tuple_usizeTransactionZ> {
-               if self.datalen == 0 { return Vec::new(); }
-               let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
-               self.data = std::ptr::null_mut();
-               self.datalen = 0;
-               ret
-       }
-       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::c_types::derived::C2Tuple_usizeTransactionZ] {
-               unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
+#[no_mangle]
+/// Creates a new CResult_SignatureNoneZ in the success state.
+pub extern "C" fn CResult_SignatureNoneZ_ok(o: crate::c_types::Signature) -> CResult_SignatureNoneZ {
+       CResult_SignatureNoneZ {
+               contents: CResult_SignatureNoneZPtr {
+                       result: Box::into_raw(Box::new(o)),
+               },
+               result_ok: true,
        }
 }
-impl From<Vec<crate::c_types::derived::C2Tuple_usizeTransactionZ>> for CVec_C2Tuple_usizeTransactionZZ {
-       fn from(v: Vec<crate::c_types::derived::C2Tuple_usizeTransactionZ>) -> Self {
-               let datalen = v.len();
-               let data = Box::into_raw(v.into_boxed_slice());
-               Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
+#[no_mangle]
+/// Creates a new CResult_SignatureNoneZ in the error state.
+pub extern "C" fn CResult_SignatureNoneZ_err() -> CResult_SignatureNoneZ {
+       CResult_SignatureNoneZ {
+               contents: CResult_SignatureNoneZPtr {
+                       err: std::ptr::null_mut(),
+               },
+               result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees the buffer pointed to by `data` if `datalen` is non-0.
-pub extern "C" fn CVec_C2Tuple_usizeTransactionZZ_free(_res: CVec_C2Tuple_usizeTransactionZZ) { }
-impl Drop for CVec_C2Tuple_usizeTransactionZZ {
+/// Frees any resources used by the CResult_SignatureNoneZ.
+pub extern "C" fn CResult_SignatureNoneZ_free(_res: CResult_SignatureNoneZ) { }
+impl Drop for CResult_SignatureNoneZ {
        fn drop(&mut self) {
-               if self.datalen == 0 { return; }
-               unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
+               if self.result_ok {
+                       if unsafe { !(self.contents.result as *mut ()).is_null() } {
+                               let _ = unsafe { Box::from_raw(self.contents.result) };
+                       }
+               } else {
+               }
        }
 }
-#[repr(C)]
-/// A tuple of 2 elements. See the individual fields for the types contained.
-pub struct C2Tuple_u32TxOutZ {
-       /// The element at position 0
-       pub a: u32,
-       /// The element at position 1
-       pub b: crate::c_types::TxOut,
-}
-impl From<(u32, crate::c_types::TxOut)> for C2Tuple_u32TxOutZ {
-       fn from (tup: (u32, crate::c_types::TxOut)) -> Self {
+impl From<crate::c_types::CResultTempl<crate::c_types::Signature, ()>> for CResult_SignatureNoneZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::c_types::Signature, ()>) -> Self {
+               let contents = if o.result_ok {
+                       let result = unsafe { o.contents.result };
+                       unsafe { o.contents.result = std::ptr::null_mut() };
+                       CResult_SignatureNoneZPtr { result }
+               } else {
+                       let _ = unsafe { Box::from_raw(o.contents.err) };
+                       o.contents.err = std::ptr::null_mut();
+                       CResult_SignatureNoneZPtr { err: std::ptr::null_mut() }
+               };
                Self {
-                       a: tup.0,
-                       b: tup.1,
+                       contents,
+                       result_ok: o.result_ok,
                }
        }
 }
-impl C2Tuple_u32TxOutZ {
-       #[allow(unused)] pub(crate) fn to_rust(mut self) -> (u32, crate::c_types::TxOut) {
-               (self.a, self.b)
-       }
-}
-impl Clone for C2Tuple_u32TxOutZ {
+impl Clone for CResult_SignatureNoneZ {
        fn clone(&self) -> Self {
-               Self {
-                       a: self.a.clone(),
-                       b: self.b.clone(),
+               if self.result_ok {
+                       Self { result_ok: true, contents: CResult_SignatureNoneZPtr {
+                               result: Box::into_raw(Box::new(<crate::c_types::Signature>::clone(unsafe { &*self.contents.result })))
+                       } }
+               } else {
+                       Self { result_ok: false, contents: CResult_SignatureNoneZPtr {
+                               err: std::ptr::null_mut()
+                       } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new tuple which has the same data as `orig`
+/// Creates a new CResult_SignatureNoneZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn C2Tuple_u32TxOutZ_clone(orig: &C2Tuple_u32TxOutZ) -> C2Tuple_u32TxOutZ { orig.clone() }
-/// Creates a new C2Tuple_u32TxOutZ from the contained elements.
-#[no_mangle]
-pub extern "C" fn C2Tuple_u32TxOutZ_new(a: u32, b: crate::c_types::TxOut) -> C2Tuple_u32TxOutZ {
-       C2Tuple_u32TxOutZ { a, b, }
+pub extern "C" fn CResult_SignatureNoneZ_clone(orig: &CResult_SignatureNoneZ) -> CResult_SignatureNoneZ { orig.clone() }
+#[repr(C)]
+/// The contents of CResult_SignDecodeErrorZ
+pub union CResult_SignDecodeErrorZPtr {
+       /// A pointer to the contents in the success state.
+       /// Reading from this pointer when `result_ok` is not set is undefined.
+       pub result: *mut crate::lightning::chain::keysinterface::Sign,
+       /// A pointer to the contents in the error state.
+       /// Reading from this pointer when `result_ok` is set is undefined.
+       pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
-
-#[no_mangle]
-/// Frees any resources used by the C2Tuple_u32TxOutZ.
-pub extern "C" fn C2Tuple_u32TxOutZ_free(_res: C2Tuple_u32TxOutZ) { }
 #[repr(C)]
-/// A dynamically-allocated array of crate::c_types::derived::C2Tuple_u32TxOutZs of arbitrary size.
-/// This corresponds to std::vector in C++
-pub struct CVec_C2Tuple_u32TxOutZZ {
-       /// The elements in the array.
-       /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
-       pub data: *mut crate::c_types::derived::C2Tuple_u32TxOutZ,
-       /// The number of elements pointed to by `data`.
-       pub datalen: usize
+/// 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`.
+pub struct CResult_SignDecodeErrorZ {
+       /// The contents of this CResult_SignDecodeErrorZ, accessible via either
+       /// `err` or `result` depending on the state of `result_ok`.
+       pub contents: CResult_SignDecodeErrorZPtr,
+       /// Whether this CResult_SignDecodeErrorZ represents a success state.
+       pub result_ok: bool,
 }
-impl CVec_C2Tuple_u32TxOutZZ {
-       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::c_types::derived::C2Tuple_u32TxOutZ> {
-               if self.datalen == 0 { return Vec::new(); }
-               let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
-               self.data = std::ptr::null_mut();
-               self.datalen = 0;
-               ret
-       }
-       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::c_types::derived::C2Tuple_u32TxOutZ] {
-               unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
+#[no_mangle]
+/// Creates a new CResult_SignDecodeErrorZ in the success state.
+pub extern "C" fn CResult_SignDecodeErrorZ_ok(o: crate::lightning::chain::keysinterface::Sign) -> CResult_SignDecodeErrorZ {
+       CResult_SignDecodeErrorZ {
+               contents: CResult_SignDecodeErrorZPtr {
+                       result: Box::into_raw(Box::new(o)),
+               },
+               result_ok: true,
        }
 }
-impl From<Vec<crate::c_types::derived::C2Tuple_u32TxOutZ>> for CVec_C2Tuple_u32TxOutZZ {
-       fn from(v: Vec<crate::c_types::derived::C2Tuple_u32TxOutZ>) -> Self {
-               let datalen = v.len();
-               let data = Box::into_raw(v.into_boxed_slice());
-               Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
+#[no_mangle]
+/// Creates a new CResult_SignDecodeErrorZ in the error state.
+pub extern "C" fn CResult_SignDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_SignDecodeErrorZ {
+       CResult_SignDecodeErrorZ {
+               contents: CResult_SignDecodeErrorZPtr {
+                       err: Box::into_raw(Box::new(e)),
+               },
+               result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees the buffer pointed to by `data` if `datalen` is non-0.
-pub extern "C" fn CVec_C2Tuple_u32TxOutZZ_free(_res: CVec_C2Tuple_u32TxOutZZ) { }
-impl Drop for CVec_C2Tuple_u32TxOutZZ {
+/// Frees any resources used by the CResult_SignDecodeErrorZ.
+pub extern "C" fn CResult_SignDecodeErrorZ_free(_res: CResult_SignDecodeErrorZ) { }
+impl Drop for CResult_SignDecodeErrorZ {
        fn drop(&mut self) {
-               if self.datalen == 0 { return; }
-               unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
-       }
-}
-impl Clone for CVec_C2Tuple_u32TxOutZZ {
-       fn clone(&self) -> Self {
-               let mut res = Vec::new();
-               if self.datalen == 0 { return Self::from(res); }
-               res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
-               Self::from(res)
+               if self.result_ok {
+                       if unsafe { !(self.contents.result as *mut ()).is_null() } {
+                               let _ = unsafe { Box::from_raw(self.contents.result) };
+                       }
+               } else {
+                       if unsafe { !(self.contents.err as *mut ()).is_null() } {
+                               let _ = unsafe { Box::from_raw(self.contents.err) };
+                       }
+               }
        }
 }
-#[repr(C)]
-/// A tuple of 2 elements. See the individual fields for the types contained.
-pub struct C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ {
-       /// The element at position 0
-       pub a: crate::c_types::ThirtyTwoBytes,
-       /// The element at position 1
-       pub b: crate::c_types::derived::CVec_C2Tuple_u32TxOutZZ,
-}
-impl From<(crate::c_types::ThirtyTwoBytes, crate::c_types::derived::CVec_C2Tuple_u32TxOutZZ)> for C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ {
-       fn from (tup: (crate::c_types::ThirtyTwoBytes, crate::c_types::derived::CVec_C2Tuple_u32TxOutZZ)) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::chain::keysinterface::Sign, crate::lightning::ln::msgs::DecodeError>> for CResult_SignDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::chain::keysinterface::Sign, crate::lightning::ln::msgs::DecodeError>) -> Self {
+               let contents = if o.result_ok {
+                       let result = unsafe { o.contents.result };
+                       unsafe { o.contents.result = std::ptr::null_mut() };
+                       CResult_SignDecodeErrorZPtr { result }
+               } else {
+                       let err = unsafe { o.contents.err };
+                       unsafe { o.contents.err = std::ptr::null_mut(); }
+                       CResult_SignDecodeErrorZPtr { err }
+               };
                Self {
-                       a: tup.0,
-                       b: tup.1,
+                       contents,
+                       result_ok: o.result_ok,
                }
        }
 }
-impl C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ {
-       #[allow(unused)] pub(crate) fn to_rust(mut self) -> (crate::c_types::ThirtyTwoBytes, crate::c_types::derived::CVec_C2Tuple_u32TxOutZZ) {
-               (self.a, self.b)
+impl Clone for CResult_SignDecodeErrorZ {
+       fn clone(&self) -> Self {
+               if self.result_ok {
+                       Self { result_ok: true, contents: CResult_SignDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::chain::keysinterface::Sign>::clone(unsafe { &*self.contents.result })))
+                       } }
+               } else {
+                       Self { result_ok: false, contents: CResult_SignDecodeErrorZPtr {
+                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
+                       } }
+               }
        }
 }
-/// Creates a new C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ from the contained elements.
-#[no_mangle]
-pub extern "C" fn C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a: crate::c_types::ThirtyTwoBytes, b: crate::c_types::derived::CVec_C2Tuple_u32TxOutZZ) -> C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ {
-       C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ { a, b, }
-}
-
 #[no_mangle]
-/// Frees any resources used by the C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ.
-pub extern "C" fn C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res: C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ) { }
+/// Creates a new CResult_SignDecodeErrorZ which has the same data as `orig`
+/// but with all dynamically-allocated buffers duplicated in new buffers.
+pub extern "C" fn CResult_SignDecodeErrorZ_clone(orig: &CResult_SignDecodeErrorZ) -> CResult_SignDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// A dynamically-allocated array of crate::c_types::derived::C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZs of arbitrary size.
+/// A dynamically-allocated array of u8s of arbitrary size.
 /// This corresponds to std::vector in C++
-pub struct CVec_TransactionOutputsZ {
+pub struct CVec_u8Z {
        /// The elements in the array.
        /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
-       pub data: *mut crate::c_types::derived::C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ,
+       pub data: *mut u8,
        /// The number of elements pointed to by `data`.
        pub datalen: usize
 }
-impl CVec_TransactionOutputsZ {
-       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::c_types::derived::C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ> {
+impl CVec_u8Z {
+       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<u8> {
                if self.datalen == 0 { return Vec::new(); }
                let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
                self.data = std::ptr::null_mut();
                self.datalen = 0;
                ret
        }
-       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::c_types::derived::C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ] {
+       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[u8] {
                unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
        }
 }
-impl From<Vec<crate::c_types::derived::C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ>> for CVec_TransactionOutputsZ {
-       fn from(v: Vec<crate::c_types::derived::C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ>) -> Self {
+impl From<Vec<u8>> for CVec_u8Z {
+       fn from(v: Vec<u8>) -> Self {
                let datalen = v.len();
                let data = Box::into_raw(v.into_boxed_slice());
                Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
@@ -3337,114 +3188,84 @@ impl From<Vec<crate::c_types::derived::C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ>> fo
 }
 #[no_mangle]
 /// Frees the buffer pointed to by `data` if `datalen` is non-0.
-pub extern "C" fn CVec_TransactionOutputsZ_free(_res: CVec_TransactionOutputsZ) { }
-impl Drop for CVec_TransactionOutputsZ {
+pub extern "C" fn CVec_u8Z_free(_res: CVec_u8Z) { }
+impl Drop for CVec_u8Z {
        fn drop(&mut self) {
                if self.datalen == 0 { return; }
                unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
        }
 }
-#[repr(C)]
-/// A dynamically-allocated array of crate::c_types::ThirtyTwoBytess of arbitrary size.
-/// This corresponds to std::vector in C++
-pub struct CVec_TxidZ {
-       /// The elements in the array.
-       /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
-       pub data: *mut crate::c_types::ThirtyTwoBytes,
-       /// The number of elements pointed to by `data`.
-       pub datalen: usize
-}
-impl CVec_TxidZ {
-       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::c_types::ThirtyTwoBytes> {
-               if self.datalen == 0 { return Vec::new(); }
-               let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
-               self.data = std::ptr::null_mut();
-               self.datalen = 0;
-               ret
-       }
-       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::c_types::ThirtyTwoBytes] {
-               unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
-       }
-}
-impl From<Vec<crate::c_types::ThirtyTwoBytes>> for CVec_TxidZ {
-       fn from(v: Vec<crate::c_types::ThirtyTwoBytes>) -> Self {
-               let datalen = v.len();
-               let data = Box::into_raw(v.into_boxed_slice());
-               Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
-       }
-}
-#[no_mangle]
-/// Frees the buffer pointed to by `data` if `datalen` is non-0.
-pub extern "C" fn CVec_TxidZ_free(_res: CVec_TxidZ) { }
-impl Drop for CVec_TxidZ {
-       fn drop(&mut self) {
-               if self.datalen == 0 { return; }
-               unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
+impl Clone for CVec_u8Z {
+       fn clone(&self) -> Self {
+               let mut res = Vec::new();
+               if self.datalen == 0 { return Self::from(res); }
+               res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
+               Self::from(res)
        }
 }
 #[repr(C)]
-/// The contents of CResult_NoneChannelMonitorUpdateErrZ
-pub union CResult_NoneChannelMonitorUpdateErrZPtr {
-       /// Note that this value is always NULL, as there are no contents in the OK variant
-       pub result: *mut std::ffi::c_void,
-       /// A pointer to the contents in the error state.
-       /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::lightning::chain::channelmonitor::ChannelMonitorUpdateErr,
+/// The contents of CResult_RecoverableSignatureNoneZ
+pub union CResult_RecoverableSignatureNoneZPtr {
+       /// A pointer to the contents in the success state.
+       /// Reading from this pointer when `result_ok` is not set is undefined.
+       pub result: *mut crate::c_types::RecoverableSignature,
+       /// Note that this value is always NULL, as there are no contents in the Err variant
+       pub err: *mut std::ffi::c_void,
 }
 #[repr(C)]
-/// 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_RecoverableSignatureNoneZ represents the result of a fallible operation,
+/// containing a crate::c_types::RecoverableSignature on success and a () on failure.
 /// `result_ok` indicates the overall state, and the contents are provided via `contents`.
-pub struct CResult_NoneChannelMonitorUpdateErrZ {
-       /// The contents of this CResult_NoneChannelMonitorUpdateErrZ, accessible via either
+pub struct CResult_RecoverableSignatureNoneZ {
+       /// The contents of this CResult_RecoverableSignatureNoneZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_NoneChannelMonitorUpdateErrZPtr,
-       /// Whether this CResult_NoneChannelMonitorUpdateErrZ represents a success state.
+       pub contents: CResult_RecoverableSignatureNoneZPtr,
+       /// Whether this CResult_RecoverableSignatureNoneZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_NoneChannelMonitorUpdateErrZ in the success state.
-pub extern "C" fn CResult_NoneChannelMonitorUpdateErrZ_ok() -> CResult_NoneChannelMonitorUpdateErrZ {
-       CResult_NoneChannelMonitorUpdateErrZ {
-               contents: CResult_NoneChannelMonitorUpdateErrZPtr {
-                       result: std::ptr::null_mut(),
+/// Creates a new CResult_RecoverableSignatureNoneZ in the success state.
+pub extern "C" fn CResult_RecoverableSignatureNoneZ_ok(o: crate::c_types::RecoverableSignature) -> CResult_RecoverableSignatureNoneZ {
+       CResult_RecoverableSignatureNoneZ {
+               contents: CResult_RecoverableSignatureNoneZPtr {
+                       result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_NoneChannelMonitorUpdateErrZ in the error state.
-pub extern "C" fn CResult_NoneChannelMonitorUpdateErrZ_err(e: crate::lightning::chain::channelmonitor::ChannelMonitorUpdateErr) -> CResult_NoneChannelMonitorUpdateErrZ {
-       CResult_NoneChannelMonitorUpdateErrZ {
-               contents: CResult_NoneChannelMonitorUpdateErrZPtr {
-                       err: Box::into_raw(Box::new(e)),
+/// Creates a new CResult_RecoverableSignatureNoneZ in the error state.
+pub extern "C" fn CResult_RecoverableSignatureNoneZ_err() -> CResult_RecoverableSignatureNoneZ {
+       CResult_RecoverableSignatureNoneZ {
+               contents: CResult_RecoverableSignatureNoneZPtr {
+                       err: std::ptr::null_mut(),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_NoneChannelMonitorUpdateErrZ.
-pub extern "C" fn CResult_NoneChannelMonitorUpdateErrZ_free(_res: CResult_NoneChannelMonitorUpdateErrZ) { }
-impl Drop for CResult_NoneChannelMonitorUpdateErrZ {
+/// Frees any resources used by the CResult_RecoverableSignatureNoneZ.
+pub extern "C" fn CResult_RecoverableSignatureNoneZ_free(_res: CResult_RecoverableSignatureNoneZ) { }
+impl Drop for CResult_RecoverableSignatureNoneZ {
        fn drop(&mut self) {
                if self.result_ok {
-               } else {
-                       if unsafe { !(self.contents.err as *mut ()).is_null() } {
-                               let _ = unsafe { Box::from_raw(self.contents.err) };
+                       if unsafe { !(self.contents.result as *mut ()).is_null() } {
+                               let _ = unsafe { Box::from_raw(self.contents.result) };
                        }
+               } else {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<(), crate::lightning::chain::channelmonitor::ChannelMonitorUpdateErr>> for CResult_NoneChannelMonitorUpdateErrZ {
-       fn from(mut o: crate::c_types::CResultTempl<(), crate::lightning::chain::channelmonitor::ChannelMonitorUpdateErr>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::c_types::RecoverableSignature, ()>> for CResult_RecoverableSignatureNoneZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::c_types::RecoverableSignature, ()>) -> Self {
                let contents = if o.result_ok {
-                       let _ = unsafe { Box::from_raw(o.contents.result) };
-                       o.contents.result = std::ptr::null_mut();
-                       CResult_NoneChannelMonitorUpdateErrZPtr { result: std::ptr::null_mut() }
+                       let result = unsafe { o.contents.result };
+                       unsafe { o.contents.result = std::ptr::null_mut() };
+                       CResult_RecoverableSignatureNoneZPtr { result }
                } else {
-                       let err = unsafe { o.contents.err };
-                       unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_NoneChannelMonitorUpdateErrZPtr { err }
+                       let _ = unsafe { Box::from_raw(o.contents.err) };
+                       o.contents.err = std::ptr::null_mut();
+                       CResult_RecoverableSignatureNoneZPtr { err: std::ptr::null_mut() }
                };
                Self {
                        contents,
@@ -3452,120 +3273,132 @@ impl From<crate::c_types::CResultTempl<(), crate::lightning::chain::channelmonit
                }
        }
 }
-impl Clone for CResult_NoneChannelMonitorUpdateErrZ {
+impl Clone for CResult_RecoverableSignatureNoneZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_NoneChannelMonitorUpdateErrZPtr {
-                               result: std::ptr::null_mut()
+                       Self { result_ok: true, contents: CResult_RecoverableSignatureNoneZPtr {
+                               result: Box::into_raw(Box::new(<crate::c_types::RecoverableSignature>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_NoneChannelMonitorUpdateErrZPtr {
-                               err: Box::into_raw(Box::new(<crate::lightning::chain::channelmonitor::ChannelMonitorUpdateErr>::clone(unsafe { &*self.contents.err })))
+                       Self { result_ok: false, contents: CResult_RecoverableSignatureNoneZPtr {
+                               err: std::ptr::null_mut()
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_NoneChannelMonitorUpdateErrZ which has the same data as `orig`
+/// Creates a new CResult_RecoverableSignatureNoneZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_NoneChannelMonitorUpdateErrZ_clone(orig: &CResult_NoneChannelMonitorUpdateErrZ) -> CResult_NoneChannelMonitorUpdateErrZ { orig.clone() }
+pub extern "C" fn CResult_RecoverableSignatureNoneZ_clone(orig: &CResult_RecoverableSignatureNoneZ) -> CResult_RecoverableSignatureNoneZ { orig.clone() }
 #[repr(C)]
-/// A tuple of 2 elements. See the individual fields for the types contained.
-pub struct C2Tuple_BlockHashChannelMonitorZ {
-       /// The element at position 0
-       pub a: crate::c_types::ThirtyTwoBytes,
-       /// The element at position 1
-       pub b: crate::lightning::chain::channelmonitor::ChannelMonitor,
+/// A dynamically-allocated array of crate::c_types::derived::CVec_u8Zs of arbitrary size.
+/// This corresponds to std::vector in C++
+pub struct CVec_CVec_u8ZZ {
+       /// The elements in the array.
+       /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+       pub data: *mut crate::c_types::derived::CVec_u8Z,
+       /// The number of elements pointed to by `data`.
+       pub datalen: usize
 }
-impl From<(crate::c_types::ThirtyTwoBytes, crate::lightning::chain::channelmonitor::ChannelMonitor)> for C2Tuple_BlockHashChannelMonitorZ {
-       fn from (tup: (crate::c_types::ThirtyTwoBytes, crate::lightning::chain::channelmonitor::ChannelMonitor)) -> Self {
-               Self {
-                       a: tup.0,
-                       b: tup.1,
-               }
+impl CVec_CVec_u8ZZ {
+       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::c_types::derived::CVec_u8Z> {
+               if self.datalen == 0 { return Vec::new(); }
+               let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
+               self.data = std::ptr::null_mut();
+               self.datalen = 0;
+               ret
+       }
+       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::c_types::derived::CVec_u8Z] {
+               unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
        }
 }
-impl C2Tuple_BlockHashChannelMonitorZ {
-       #[allow(unused)] pub(crate) fn to_rust(mut self) -> (crate::c_types::ThirtyTwoBytes, crate::lightning::chain::channelmonitor::ChannelMonitor) {
-               (self.a, self.b)
+impl From<Vec<crate::c_types::derived::CVec_u8Z>> for CVec_CVec_u8ZZ {
+       fn from(v: Vec<crate::c_types::derived::CVec_u8Z>) -> Self {
+               let datalen = v.len();
+               let data = Box::into_raw(v.into_boxed_slice());
+               Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
        }
 }
-/// Creates a new C2Tuple_BlockHashChannelMonitorZ from the contained elements.
 #[no_mangle]
-pub extern "C" fn C2Tuple_BlockHashChannelMonitorZ_new(a: crate::c_types::ThirtyTwoBytes, b: crate::lightning::chain::channelmonitor::ChannelMonitor) -> C2Tuple_BlockHashChannelMonitorZ {
-       C2Tuple_BlockHashChannelMonitorZ { a, b, }
+/// Frees the buffer pointed to by `data` if `datalen` is non-0.
+pub extern "C" fn CVec_CVec_u8ZZ_free(_res: CVec_CVec_u8ZZ) { }
+impl Drop for CVec_CVec_u8ZZ {
+       fn drop(&mut self) {
+               if self.datalen == 0 { return; }
+               unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
+       }
+}
+impl Clone for CVec_CVec_u8ZZ {
+       fn clone(&self) -> Self {
+               let mut res = Vec::new();
+               if self.datalen == 0 { return Self::from(res); }
+               res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
+               Self::from(res)
+       }
 }
-
-#[no_mangle]
-/// Frees any resources used by the C2Tuple_BlockHashChannelMonitorZ.
-pub extern "C" fn C2Tuple_BlockHashChannelMonitorZ_free(_res: C2Tuple_BlockHashChannelMonitorZ) { }
 #[repr(C)]
-/// The contents of CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ
-pub union CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZPtr {
+/// The contents of CResult_CVec_CVec_u8ZZNoneZ
+pub union CResult_CVec_CVec_u8ZZNoneZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::c_types::derived::C2Tuple_BlockHashChannelMonitorZ,
-       /// A pointer to the contents in the error state.
-       /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::lightning::ln::msgs::DecodeError,
+       pub result: *mut crate::c_types::derived::CVec_CVec_u8ZZ,
+       /// Note that this value is always NULL, as there are no contents in the Err variant
+       pub err: *mut std::ffi::c_void,
 }
 #[repr(C)]
-/// 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.
+/// 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`.
-pub struct CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ {
-       /// The contents of this CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ, accessible via either
+pub struct CResult_CVec_CVec_u8ZZNoneZ {
+       /// The contents of this CResult_CVec_CVec_u8ZZNoneZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZPtr,
-       /// Whether this CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ represents a success state.
+       pub contents: CResult_CVec_CVec_u8ZZNoneZPtr,
+       /// Whether this CResult_CVec_CVec_u8ZZNoneZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ in the success state.
-pub extern "C" fn CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o: crate::c_types::derived::C2Tuple_BlockHashChannelMonitorZ) -> CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ {
-       CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ {
-               contents: CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZPtr {
+/// Creates a new CResult_CVec_CVec_u8ZZNoneZ in the success state.
+pub extern "C" fn CResult_CVec_CVec_u8ZZNoneZ_ok(o: crate::c_types::derived::CVec_CVec_u8ZZ) -> CResult_CVec_CVec_u8ZZNoneZ {
+       CResult_CVec_CVec_u8ZZNoneZ {
+               contents: CResult_CVec_CVec_u8ZZNoneZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ in the error state.
-pub extern "C" fn CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ {
-       CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ {
-               contents: CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZPtr {
-                       err: Box::into_raw(Box::new(e)),
+/// Creates a new CResult_CVec_CVec_u8ZZNoneZ in the error state.
+pub extern "C" fn CResult_CVec_CVec_u8ZZNoneZ_err() -> CResult_CVec_CVec_u8ZZNoneZ {
+       CResult_CVec_CVec_u8ZZNoneZ {
+               contents: CResult_CVec_CVec_u8ZZNoneZPtr {
+                       err: std::ptr::null_mut(),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ.
-pub extern "C" fn CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res: CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ) { }
-impl Drop for CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ {
+/// Frees any resources used by the CResult_CVec_CVec_u8ZZNoneZ.
+pub extern "C" fn CResult_CVec_CVec_u8ZZNoneZ_free(_res: CResult_CVec_CVec_u8ZZNoneZ) { }
+impl Drop for CResult_CVec_CVec_u8ZZNoneZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
                                let _ = unsafe { Box::from_raw(self.contents.result) };
                        }
                } else {
-                       if unsafe { !(self.contents.err as *mut ()).is_null() } {
-                               let _ = unsafe { Box::from_raw(self.contents.err) };
-                       }
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::c_types::derived::C2Tuple_BlockHashChannelMonitorZ, crate::lightning::ln::msgs::DecodeError>> for CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::c_types::derived::C2Tuple_BlockHashChannelMonitorZ, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::c_types::derived::CVec_CVec_u8ZZ, ()>> for CResult_CVec_CVec_u8ZZNoneZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::c_types::derived::CVec_CVec_u8ZZ, ()>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZPtr { result }
+                       CResult_CVec_CVec_u8ZZNoneZPtr { result }
                } else {
-                       let err = unsafe { o.contents.err };
-                       unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZPtr { err }
+                       let _ = unsafe { Box::from_raw(o.contents.err) };
+                       o.contents.err = std::ptr::null_mut();
+                       CResult_CVec_CVec_u8ZZNoneZPtr { err: std::ptr::null_mut() }
                };
                Self {
                        contents,
@@ -3573,51 +3406,68 @@ impl From<crate::c_types::CResultTempl<crate::c_types::derived::C2Tuple_BlockHas
                }
        }
 }
+impl Clone for CResult_CVec_CVec_u8ZZNoneZ {
+       fn clone(&self) -> Self {
+               if self.result_ok {
+                       Self { result_ok: true, contents: CResult_CVec_CVec_u8ZZNoneZPtr {
+                               result: Box::into_raw(Box::new(<crate::c_types::derived::CVec_CVec_u8ZZ>::clone(unsafe { &*self.contents.result })))
+                       } }
+               } else {
+                       Self { result_ok: false, contents: CResult_CVec_CVec_u8ZZNoneZPtr {
+                               err: std::ptr::null_mut()
+                       } }
+               }
+       }
+}
+#[no_mangle]
+/// Creates a new CResult_CVec_CVec_u8ZZNoneZ which has the same data as `orig`
+/// but with all dynamically-allocated buffers duplicated in new buffers.
+pub extern "C" fn CResult_CVec_CVec_u8ZZNoneZ_clone(orig: &CResult_CVec_CVec_u8ZZNoneZ) -> CResult_CVec_CVec_u8ZZNoneZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_RouteHopDecodeErrorZ
-pub union CResult_RouteHopDecodeErrorZPtr {
+/// The contents of CResult_InMemorySignerDecodeErrorZ
+pub union CResult_InMemorySignerDecodeErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::routing::router::RouteHop,
+       pub result: *mut crate::lightning::chain::keysinterface::InMemorySigner,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
        pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// A CResult_RouteHopDecodeErrorZ represents the result of a fallible operation,
-/// containing a crate::lightning::routing::router::RouteHop 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`.
-pub struct CResult_RouteHopDecodeErrorZ {
-       /// The contents of this CResult_RouteHopDecodeErrorZ, accessible via either
+pub struct CResult_InMemorySignerDecodeErrorZ {
+       /// The contents of this CResult_InMemorySignerDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_RouteHopDecodeErrorZPtr,
-       /// Whether this CResult_RouteHopDecodeErrorZ represents a success state.
+       pub contents: CResult_InMemorySignerDecodeErrorZPtr,
+       /// Whether this CResult_InMemorySignerDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_RouteHopDecodeErrorZ in the success state.
-pub extern "C" fn CResult_RouteHopDecodeErrorZ_ok(o: crate::lightning::routing::router::RouteHop) -> CResult_RouteHopDecodeErrorZ {
-       CResult_RouteHopDecodeErrorZ {
-               contents: CResult_RouteHopDecodeErrorZPtr {
+/// Creates a new CResult_InMemorySignerDecodeErrorZ in the success state.
+pub extern "C" fn CResult_InMemorySignerDecodeErrorZ_ok(o: crate::lightning::chain::keysinterface::InMemorySigner) -> CResult_InMemorySignerDecodeErrorZ {
+       CResult_InMemorySignerDecodeErrorZ {
+               contents: CResult_InMemorySignerDecodeErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_RouteHopDecodeErrorZ in the error state.
-pub extern "C" fn CResult_RouteHopDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_RouteHopDecodeErrorZ {
-       CResult_RouteHopDecodeErrorZ {
-               contents: CResult_RouteHopDecodeErrorZPtr {
+/// Creates a new CResult_InMemorySignerDecodeErrorZ in the error state.
+pub extern "C" fn CResult_InMemorySignerDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_InMemorySignerDecodeErrorZ {
+       CResult_InMemorySignerDecodeErrorZ {
+               contents: CResult_InMemorySignerDecodeErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_RouteHopDecodeErrorZ.
-pub extern "C" fn CResult_RouteHopDecodeErrorZ_free(_res: CResult_RouteHopDecodeErrorZ) { }
-impl Drop for CResult_RouteHopDecodeErrorZ {
+/// Frees any resources used by the CResult_InMemorySignerDecodeErrorZ.
+pub extern "C" fn CResult_InMemorySignerDecodeErrorZ_free(_res: CResult_InMemorySignerDecodeErrorZ) { }
+impl Drop for CResult_InMemorySignerDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -3630,16 +3480,16 @@ impl Drop for CResult_RouteHopDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::routing::router::RouteHop, crate::lightning::ln::msgs::DecodeError>> for CResult_RouteHopDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::routing::router::RouteHop, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::chain::keysinterface::InMemorySigner, crate::lightning::ln::msgs::DecodeError>> for CResult_InMemorySignerDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::chain::keysinterface::InMemorySigner, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_RouteHopDecodeErrorZPtr { result }
+                       CResult_InMemorySignerDecodeErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_RouteHopDecodeErrorZPtr { err }
+                       CResult_InMemorySignerDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -3647,47 +3497,47 @@ impl From<crate::c_types::CResultTempl<crate::lightning::routing::router::RouteH
                }
        }
 }
-impl Clone for CResult_RouteHopDecodeErrorZ {
+impl Clone for CResult_InMemorySignerDecodeErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_RouteHopDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::routing::router::RouteHop>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_InMemorySignerDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::chain::keysinterface::InMemorySigner>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_RouteHopDecodeErrorZPtr {
+                       Self { result_ok: false, contents: CResult_InMemorySignerDecodeErrorZPtr {
                                err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_RouteHopDecodeErrorZ which has the same data as `orig`
+/// Creates a new CResult_InMemorySignerDecodeErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_RouteHopDecodeErrorZ_clone(orig: &CResult_RouteHopDecodeErrorZ) -> CResult_RouteHopDecodeErrorZ { orig.clone() }
+pub extern "C" fn CResult_InMemorySignerDecodeErrorZ_clone(orig: &CResult_InMemorySignerDecodeErrorZ) -> CResult_InMemorySignerDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// A dynamically-allocated array of crate::lightning::routing::router::RouteHops of arbitrary size.
+/// A dynamically-allocated array of crate::c_types::TxOuts of arbitrary size.
 /// This corresponds to std::vector in C++
-pub struct CVec_RouteHopZ {
+pub struct CVec_TxOutZ {
        /// The elements in the array.
        /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
-       pub data: *mut crate::lightning::routing::router::RouteHop,
+       pub data: *mut crate::c_types::TxOut,
        /// The number of elements pointed to by `data`.
        pub datalen: usize
 }
-impl CVec_RouteHopZ {
-       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::lightning::routing::router::RouteHop> {
+impl CVec_TxOutZ {
+       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::c_types::TxOut> {
                if self.datalen == 0 { return Vec::new(); }
                let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
                self.data = std::ptr::null_mut();
                self.datalen = 0;
                ret
        }
-       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::lightning::routing::router::RouteHop] {
+       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::c_types::TxOut] {
                unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
        }
 }
-impl From<Vec<crate::lightning::routing::router::RouteHop>> for CVec_RouteHopZ {
-       fn from(v: Vec<crate::lightning::routing::router::RouteHop>) -> Self {
+impl From<Vec<crate::c_types::TxOut>> for CVec_TxOutZ {
+       fn from(v: Vec<crate::c_types::TxOut>) -> Self {
                let datalen = v.len();
                let data = Box::into_raw(v.into_boxed_slice());
                Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
@@ -3695,14 +3545,14 @@ impl From<Vec<crate::lightning::routing::router::RouteHop>> for CVec_RouteHopZ {
 }
 #[no_mangle]
 /// Frees the buffer pointed to by `data` if `datalen` is non-0.
-pub extern "C" fn CVec_RouteHopZ_free(_res: CVec_RouteHopZ) { }
-impl Drop for CVec_RouteHopZ {
+pub extern "C" fn CVec_TxOutZ_free(_res: CVec_TxOutZ) { }
+impl Drop for CVec_TxOutZ {
        fn drop(&mut self) {
                if self.datalen == 0 { return; }
                unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
        }
 }
-impl Clone for CVec_RouteHopZ {
+impl Clone for CVec_TxOutZ {
        fn clone(&self) -> Self {
                let mut res = Vec::new();
                if self.datalen == 0 { return Self::from(res); }
@@ -3711,29 +3561,146 @@ impl Clone for CVec_RouteHopZ {
        }
 }
 #[repr(C)]
-/// A dynamically-allocated array of crate::c_types::derived::CVec_RouteHopZs of arbitrary size.
+/// The contents of CResult_TransactionNoneZ
+pub union CResult_TransactionNoneZPtr {
+       /// A pointer to the contents in the success state.
+       /// Reading from this pointer when `result_ok` is not set is undefined.
+       pub result: *mut crate::c_types::Transaction,
+       /// Note that this value is always NULL, as there are no contents in the Err variant
+       pub err: *mut std::ffi::c_void,
+}
+#[repr(C)]
+/// 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`.
+pub struct CResult_TransactionNoneZ {
+       /// The contents of this CResult_TransactionNoneZ, accessible via either
+       /// `err` or `result` depending on the state of `result_ok`.
+       pub contents: CResult_TransactionNoneZPtr,
+       /// Whether this CResult_TransactionNoneZ represents a success state.
+       pub result_ok: bool,
+}
+#[no_mangle]
+/// Creates a new CResult_TransactionNoneZ in the success state.
+pub extern "C" fn CResult_TransactionNoneZ_ok(o: crate::c_types::Transaction) -> CResult_TransactionNoneZ {
+       CResult_TransactionNoneZ {
+               contents: CResult_TransactionNoneZPtr {
+                       result: Box::into_raw(Box::new(o)),
+               },
+               result_ok: true,
+       }
+}
+#[no_mangle]
+/// Creates a new CResult_TransactionNoneZ in the error state.
+pub extern "C" fn CResult_TransactionNoneZ_err() -> CResult_TransactionNoneZ {
+       CResult_TransactionNoneZ {
+               contents: CResult_TransactionNoneZPtr {
+                       err: std::ptr::null_mut(),
+               },
+               result_ok: false,
+       }
+}
+#[no_mangle]
+/// Frees any resources used by the CResult_TransactionNoneZ.
+pub extern "C" fn CResult_TransactionNoneZ_free(_res: CResult_TransactionNoneZ) { }
+impl Drop for CResult_TransactionNoneZ {
+       fn drop(&mut self) {
+               if self.result_ok {
+                       if unsafe { !(self.contents.result as *mut ()).is_null() } {
+                               let _ = unsafe { Box::from_raw(self.contents.result) };
+                       }
+               } else {
+               }
+       }
+}
+impl From<crate::c_types::CResultTempl<crate::c_types::Transaction, ()>> for CResult_TransactionNoneZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::c_types::Transaction, ()>) -> Self {
+               let contents = if o.result_ok {
+                       let result = unsafe { o.contents.result };
+                       unsafe { o.contents.result = std::ptr::null_mut() };
+                       CResult_TransactionNoneZPtr { result }
+               } else {
+                       let _ = unsafe { Box::from_raw(o.contents.err) };
+                       o.contents.err = std::ptr::null_mut();
+                       CResult_TransactionNoneZPtr { err: std::ptr::null_mut() }
+               };
+               Self {
+                       contents,
+                       result_ok: o.result_ok,
+               }
+       }
+}
+impl Clone for CResult_TransactionNoneZ {
+       fn clone(&self) -> Self {
+               if self.result_ok {
+                       Self { result_ok: true, contents: CResult_TransactionNoneZPtr {
+                               result: Box::into_raw(Box::new(<crate::c_types::Transaction>::clone(unsafe { &*self.contents.result })))
+                       } }
+               } else {
+                       Self { result_ok: false, contents: CResult_TransactionNoneZPtr {
+                               err: std::ptr::null_mut()
+                       } }
+               }
+       }
+}
+#[no_mangle]
+/// Creates a new CResult_TransactionNoneZ which has the same data as `orig`
+/// but with all dynamically-allocated buffers duplicated in new buffers.
+pub extern "C" fn CResult_TransactionNoneZ_clone(orig: &CResult_TransactionNoneZ) -> CResult_TransactionNoneZ { orig.clone() }
+#[repr(C)]
+/// A tuple of 2 elements. See the individual fields for the types contained.
+pub struct C2Tuple_BlockHashChannelMonitorZ {
+       /// The element at position 0
+       pub a: crate::c_types::ThirtyTwoBytes,
+       /// The element at position 1
+       pub b: crate::lightning::chain::channelmonitor::ChannelMonitor,
+}
+impl From<(crate::c_types::ThirtyTwoBytes, crate::lightning::chain::channelmonitor::ChannelMonitor)> for C2Tuple_BlockHashChannelMonitorZ {
+       fn from (tup: (crate::c_types::ThirtyTwoBytes, crate::lightning::chain::channelmonitor::ChannelMonitor)) -> Self {
+               Self {
+                       a: tup.0,
+                       b: tup.1,
+               }
+       }
+}
+impl C2Tuple_BlockHashChannelMonitorZ {
+       #[allow(unused)] pub(crate) fn to_rust(mut self) -> (crate::c_types::ThirtyTwoBytes, crate::lightning::chain::channelmonitor::ChannelMonitor) {
+               (self.a, self.b)
+       }
+}
+/// Creates a new C2Tuple_BlockHashChannelMonitorZ from the contained elements.
+#[no_mangle]
+pub extern "C" fn C2Tuple_BlockHashChannelMonitorZ_new(a: crate::c_types::ThirtyTwoBytes, b: crate::lightning::chain::channelmonitor::ChannelMonitor) -> C2Tuple_BlockHashChannelMonitorZ {
+       C2Tuple_BlockHashChannelMonitorZ { a, b, }
+}
+
+#[no_mangle]
+/// Frees any resources used by the C2Tuple_BlockHashChannelMonitorZ.
+pub extern "C" fn C2Tuple_BlockHashChannelMonitorZ_free(_res: C2Tuple_BlockHashChannelMonitorZ) { }
+#[repr(C)]
+/// A dynamically-allocated array of crate::c_types::derived::C2Tuple_BlockHashChannelMonitorZs of arbitrary size.
 /// This corresponds to std::vector in C++
-pub struct CVec_CVec_RouteHopZZ {
+pub struct CVec_C2Tuple_BlockHashChannelMonitorZZ {
        /// The elements in the array.
        /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
-       pub data: *mut crate::c_types::derived::CVec_RouteHopZ,
+       pub data: *mut crate::c_types::derived::C2Tuple_BlockHashChannelMonitorZ,
        /// The number of elements pointed to by `data`.
        pub datalen: usize
 }
-impl CVec_CVec_RouteHopZZ {
-       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::c_types::derived::CVec_RouteHopZ> {
+impl CVec_C2Tuple_BlockHashChannelMonitorZZ {
+       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::c_types::derived::C2Tuple_BlockHashChannelMonitorZ> {
                if self.datalen == 0 { return Vec::new(); }
                let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
                self.data = std::ptr::null_mut();
                self.datalen = 0;
                ret
        }
-       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::c_types::derived::CVec_RouteHopZ] {
+       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::c_types::derived::C2Tuple_BlockHashChannelMonitorZ] {
                unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
        }
 }
-impl From<Vec<crate::c_types::derived::CVec_RouteHopZ>> for CVec_CVec_RouteHopZZ {
-       fn from(v: Vec<crate::c_types::derived::CVec_RouteHopZ>) -> Self {
+impl From<Vec<crate::c_types::derived::C2Tuple_BlockHashChannelMonitorZ>> for CVec_C2Tuple_BlockHashChannelMonitorZZ {
+       fn from(v: Vec<crate::c_types::derived::C2Tuple_BlockHashChannelMonitorZ>) -> Self {
                let datalen = v.len();
                let data = Box::into_raw(v.into_boxed_slice());
                Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
@@ -3741,66 +3708,58 @@ impl From<Vec<crate::c_types::derived::CVec_RouteHopZ>> for CVec_CVec_RouteHopZZ
 }
 #[no_mangle]
 /// Frees the buffer pointed to by `data` if `datalen` is non-0.
-pub extern "C" fn CVec_CVec_RouteHopZZ_free(_res: CVec_CVec_RouteHopZZ) { }
-impl Drop for CVec_CVec_RouteHopZZ {
+pub extern "C" fn CVec_C2Tuple_BlockHashChannelMonitorZZ_free(_res: CVec_C2Tuple_BlockHashChannelMonitorZZ) { }
+impl Drop for CVec_C2Tuple_BlockHashChannelMonitorZZ {
        fn drop(&mut self) {
                if self.datalen == 0 { return; }
                unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
        }
 }
-impl Clone for CVec_CVec_RouteHopZZ {
-       fn clone(&self) -> Self {
-               let mut res = Vec::new();
-               if self.datalen == 0 { return Self::from(res); }
-               res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
-               Self::from(res)
-       }
-}
 #[repr(C)]
-/// The contents of CResult_RouteDecodeErrorZ
-pub union CResult_RouteDecodeErrorZPtr {
+/// The contents of CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ
+pub union CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::routing::router::Route,
+       pub result: *mut crate::c_types::derived::CVec_C2Tuple_BlockHashChannelMonitorZZ,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::lightning::ln::msgs::DecodeError,
+       pub err: *mut crate::c_types::IOError,
 }
 #[repr(C)]
-/// 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.
+/// 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`.
-pub struct CResult_RouteDecodeErrorZ {
-       /// The contents of this CResult_RouteDecodeErrorZ, accessible via either
+pub struct CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ {
+       /// The contents of this CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_RouteDecodeErrorZPtr,
-       /// Whether this CResult_RouteDecodeErrorZ represents a success state.
+       pub contents: CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZPtr,
+       /// Whether this CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_RouteDecodeErrorZ in the success state.
-pub extern "C" fn CResult_RouteDecodeErrorZ_ok(o: crate::lightning::routing::router::Route) -> CResult_RouteDecodeErrorZ {
-       CResult_RouteDecodeErrorZ {
-               contents: CResult_RouteDecodeErrorZPtr {
+/// Creates a new CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ in the success state.
+pub extern "C" fn CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_ok(o: crate::c_types::derived::CVec_C2Tuple_BlockHashChannelMonitorZZ) -> CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ {
+       CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ {
+               contents: CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_RouteDecodeErrorZ in the error state.
-pub extern "C" fn CResult_RouteDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_RouteDecodeErrorZ {
-       CResult_RouteDecodeErrorZ {
-               contents: CResult_RouteDecodeErrorZPtr {
+/// Creates a new CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ in the error state.
+pub extern "C" fn CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_err(e: crate::c_types::IOError) -> CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ {
+       CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ {
+               contents: CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_RouteDecodeErrorZ.
-pub extern "C" fn CResult_RouteDecodeErrorZ_free(_res: CResult_RouteDecodeErrorZ) { }
-impl Drop for CResult_RouteDecodeErrorZ {
+/// Frees any resources used by the CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ.
+pub extern "C" fn CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_free(_res: CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ) { }
+impl Drop for CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -3813,16 +3772,16 @@ impl Drop for CResult_RouteDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::routing::router::Route, crate::lightning::ln::msgs::DecodeError>> for CResult_RouteDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::routing::router::Route, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::c_types::derived::CVec_C2Tuple_BlockHashChannelMonitorZZ, crate::c_types::IOError>> for CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::c_types::derived::CVec_C2Tuple_BlockHashChannelMonitorZZ, crate::c_types::IOError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_RouteDecodeErrorZPtr { result }
+                       CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_RouteDecodeErrorZPtr { err }
+                       CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZPtr { err }
                };
                Self {
                        contents,
@@ -3830,119 +3789,52 @@ impl From<crate::c_types::CResultTempl<crate::lightning::routing::router::Route,
                }
        }
 }
-impl Clone for CResult_RouteDecodeErrorZ {
-       fn clone(&self) -> Self {
-               if self.result_ok {
-                       Self { result_ok: true, contents: CResult_RouteDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::routing::router::Route>::clone(unsafe { &*self.contents.result })))
-                       } }
-               } else {
-                       Self { result_ok: false, contents: CResult_RouteDecodeErrorZPtr {
-                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
-                       } }
-               }
-       }
-}
-#[no_mangle]
-/// Creates a new CResult_RouteDecodeErrorZ which has the same data as `orig`
-/// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_RouteDecodeErrorZ_clone(orig: &CResult_RouteDecodeErrorZ) -> CResult_RouteDecodeErrorZ { orig.clone() }
-#[repr(C)]
-/// A dynamically-allocated array of crate::lightning::ln::channelmanager::ChannelDetailss of arbitrary size.
-/// This corresponds to std::vector in C++
-pub struct CVec_ChannelDetailsZ {
-       /// The elements in the array.
-       /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
-       pub data: *mut crate::lightning::ln::channelmanager::ChannelDetails,
-       /// The number of elements pointed to by `data`.
-       pub datalen: usize
-}
-impl CVec_ChannelDetailsZ {
-       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::lightning::ln::channelmanager::ChannelDetails> {
-               if self.datalen == 0 { return Vec::new(); }
-               let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
-               self.data = std::ptr::null_mut();
-               self.datalen = 0;
-               ret
-       }
-       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::lightning::ln::channelmanager::ChannelDetails] {
-               unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
-       }
-}
-impl From<Vec<crate::lightning::ln::channelmanager::ChannelDetails>> for CVec_ChannelDetailsZ {
-       fn from(v: Vec<crate::lightning::ln::channelmanager::ChannelDetails>) -> Self {
-               let datalen = v.len();
-               let data = Box::into_raw(v.into_boxed_slice());
-               Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
-       }
-}
-#[no_mangle]
-/// Frees the buffer pointed to by `data` if `datalen` is non-0.
-pub extern "C" fn CVec_ChannelDetailsZ_free(_res: CVec_ChannelDetailsZ) { }
-impl Drop for CVec_ChannelDetailsZ {
-       fn drop(&mut self) {
-               if self.datalen == 0 { return; }
-               unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
-       }
-}
-impl Clone for CVec_ChannelDetailsZ {
-       fn clone(&self) -> Self {
-               let mut res = Vec::new();
-               if self.datalen == 0 { return Self::from(res); }
-               res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
-               Self::from(res)
-       }
-}
 #[repr(C)]
-/// The contents of CResult_RouteLightningErrorZ
-pub union CResult_RouteLightningErrorZPtr {
-       /// A pointer to the contents in the success state.
-       /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::routing::router::Route,
+/// The contents of CResult_NoneAPIErrorZ
+pub union CResult_NoneAPIErrorZPtr {
+       /// Note that this value is always NULL, as there are no contents in the OK variant
+       pub result: *mut std::ffi::c_void,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::lightning::ln::msgs::LightningError,
+       pub err: *mut crate::lightning::util::errors::APIError,
 }
 #[repr(C)]
-/// 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.
+/// A CResult_NoneAPIErrorZ represents the result of a fallible operation,
+/// containing a () on success and a crate::lightning::util::errors::APIError on failure.
 /// `result_ok` indicates the overall state, and the contents are provided via `contents`.
-pub struct CResult_RouteLightningErrorZ {
-       /// The contents of this CResult_RouteLightningErrorZ, accessible via either
+pub struct CResult_NoneAPIErrorZ {
+       /// The contents of this CResult_NoneAPIErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_RouteLightningErrorZPtr,
-       /// Whether this CResult_RouteLightningErrorZ represents a success state.
+       pub contents: CResult_NoneAPIErrorZPtr,
+       /// Whether this CResult_NoneAPIErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_RouteLightningErrorZ in the success state.
-pub extern "C" fn CResult_RouteLightningErrorZ_ok(o: crate::lightning::routing::router::Route) -> CResult_RouteLightningErrorZ {
-       CResult_RouteLightningErrorZ {
-               contents: CResult_RouteLightningErrorZPtr {
-                       result: Box::into_raw(Box::new(o)),
+/// Creates a new CResult_NoneAPIErrorZ in the success state.
+pub extern "C" fn CResult_NoneAPIErrorZ_ok() -> CResult_NoneAPIErrorZ {
+       CResult_NoneAPIErrorZ {
+               contents: CResult_NoneAPIErrorZPtr {
+                       result: std::ptr::null_mut(),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_RouteLightningErrorZ in the error state.
-pub extern "C" fn CResult_RouteLightningErrorZ_err(e: crate::lightning::ln::msgs::LightningError) -> CResult_RouteLightningErrorZ {
-       CResult_RouteLightningErrorZ {
-               contents: CResult_RouteLightningErrorZPtr {
+/// Creates a new CResult_NoneAPIErrorZ in the error state.
+pub extern "C" fn CResult_NoneAPIErrorZ_err(e: crate::lightning::util::errors::APIError) -> CResult_NoneAPIErrorZ {
+       CResult_NoneAPIErrorZ {
+               contents: CResult_NoneAPIErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_RouteLightningErrorZ.
-pub extern "C" fn CResult_RouteLightningErrorZ_free(_res: CResult_RouteLightningErrorZ) { }
-impl Drop for CResult_RouteLightningErrorZ {
+/// Frees any resources used by the CResult_NoneAPIErrorZ.
+pub extern "C" fn CResult_NoneAPIErrorZ_free(_res: CResult_NoneAPIErrorZ) { }
+impl Drop for CResult_NoneAPIErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
-                       if unsafe { !(self.contents.result as *mut ()).is_null() } {
-                               let _ = unsafe { Box::from_raw(self.contents.result) };
-                       }
                } else {
                        if unsafe { !(self.contents.err as *mut ()).is_null() } {
                                let _ = unsafe { Box::from_raw(self.contents.err) };
@@ -3950,16 +3842,16 @@ impl Drop for CResult_RouteLightningErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::routing::router::Route, crate::lightning::ln::msgs::LightningError>> for CResult_RouteLightningErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::routing::router::Route, crate::lightning::ln::msgs::LightningError>) -> Self {
+impl From<crate::c_types::CResultTempl<(), crate::lightning::util::errors::APIError>> for CResult_NoneAPIErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<(), crate::lightning::util::errors::APIError>) -> Self {
                let contents = if o.result_ok {
-                       let result = unsafe { o.contents.result };
-                       unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_RouteLightningErrorZPtr { result }
+                       let _ = unsafe { Box::from_raw(o.contents.result) };
+                       o.contents.result = std::ptr::null_mut();
+                       CResult_NoneAPIErrorZPtr { result: std::ptr::null_mut() }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_RouteLightningErrorZPtr { err }
+                       CResult_NoneAPIErrorZPtr { err }
                };
                Self {
                        contents,
@@ -3967,47 +3859,93 @@ impl From<crate::c_types::CResultTempl<crate::lightning::routing::router::Route,
                }
        }
 }
-impl Clone for CResult_RouteLightningErrorZ {
+impl Clone for CResult_NoneAPIErrorZ {
+       fn clone(&self) -> Self {
+               if self.result_ok {
+                       Self { result_ok: true, contents: CResult_NoneAPIErrorZPtr {
+                               result: std::ptr::null_mut()
+                       } }
+               } else {
+                       Self { result_ok: false, contents: CResult_NoneAPIErrorZPtr {
+                               err: Box::into_raw(Box::new(<crate::lightning::util::errors::APIError>::clone(unsafe { &*self.contents.err })))
+                       } }
+               }
+       }
+}
+#[no_mangle]
+/// Creates a new CResult_NoneAPIErrorZ which has the same data as `orig`
+/// but with all dynamically-allocated buffers duplicated in new buffers.
+pub extern "C" fn CResult_NoneAPIErrorZ_clone(orig: &CResult_NoneAPIErrorZ) -> CResult_NoneAPIErrorZ { orig.clone() }
+#[repr(C)]
+/// A dynamically-allocated array of crate::c_types::derived::CResult_NoneAPIErrorZs of arbitrary size.
+/// This corresponds to std::vector in C++
+pub struct CVec_CResult_NoneAPIErrorZZ {
+       /// The elements in the array.
+       /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+       pub data: *mut crate::c_types::derived::CResult_NoneAPIErrorZ,
+       /// The number of elements pointed to by `data`.
+       pub datalen: usize
+}
+impl CVec_CResult_NoneAPIErrorZZ {
+       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::c_types::derived::CResult_NoneAPIErrorZ> {
+               if self.datalen == 0 { return Vec::new(); }
+               let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
+               self.data = std::ptr::null_mut();
+               self.datalen = 0;
+               ret
+       }
+       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::c_types::derived::CResult_NoneAPIErrorZ] {
+               unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
+       }
+}
+impl From<Vec<crate::c_types::derived::CResult_NoneAPIErrorZ>> for CVec_CResult_NoneAPIErrorZZ {
+       fn from(v: Vec<crate::c_types::derived::CResult_NoneAPIErrorZ>) -> Self {
+               let datalen = v.len();
+               let data = Box::into_raw(v.into_boxed_slice());
+               Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
+       }
+}
+#[no_mangle]
+/// Frees the buffer pointed to by `data` if `datalen` is non-0.
+pub extern "C" fn CVec_CResult_NoneAPIErrorZZ_free(_res: CVec_CResult_NoneAPIErrorZZ) { }
+impl Drop for CVec_CResult_NoneAPIErrorZZ {
+       fn drop(&mut self) {
+               if self.datalen == 0 { return; }
+               unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
+       }
+}
+impl Clone for CVec_CResult_NoneAPIErrorZZ {
        fn clone(&self) -> Self {
-               if self.result_ok {
-                       Self { result_ok: true, contents: CResult_RouteLightningErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::routing::router::Route>::clone(unsafe { &*self.contents.result })))
-                       } }
-               } else {
-                       Self { result_ok: false, contents: CResult_RouteLightningErrorZPtr {
-                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::LightningError>::clone(unsafe { &*self.contents.err })))
-                       } }
-               }
+               let mut res = Vec::new();
+               if self.datalen == 0 { return Self::from(res); }
+               res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
+               Self::from(res)
        }
 }
-#[no_mangle]
-/// Creates a new CResult_RouteLightningErrorZ which has the same data as `orig`
-/// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_RouteLightningErrorZ_clone(orig: &CResult_RouteLightningErrorZ) -> CResult_RouteLightningErrorZ { orig.clone() }
 #[repr(C)]
-/// A dynamically-allocated array of crate::lightning::util::events::MessageSendEvents of arbitrary size.
+/// A dynamically-allocated array of crate::lightning::util::errors::APIErrors of arbitrary size.
 /// This corresponds to std::vector in C++
-pub struct CVec_MessageSendEventZ {
+pub struct CVec_APIErrorZ {
        /// The elements in the array.
        /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
-       pub data: *mut crate::lightning::util::events::MessageSendEvent,
+       pub data: *mut crate::lightning::util::errors::APIError,
        /// The number of elements pointed to by `data`.
        pub datalen: usize
 }
-impl CVec_MessageSendEventZ {
-       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::lightning::util::events::MessageSendEvent> {
+impl CVec_APIErrorZ {
+       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::lightning::util::errors::APIError> {
                if self.datalen == 0 { return Vec::new(); }
                let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
                self.data = std::ptr::null_mut();
                self.datalen = 0;
                ret
        }
-       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::lightning::util::events::MessageSendEvent] {
+       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::lightning::util::errors::APIError] {
                unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
        }
 }
-impl From<Vec<crate::lightning::util::events::MessageSendEvent>> for CVec_MessageSendEventZ {
-       fn from(v: Vec<crate::lightning::util::events::MessageSendEvent>) -> Self {
+impl From<Vec<crate::lightning::util::errors::APIError>> for CVec_APIErrorZ {
+       fn from(v: Vec<crate::lightning::util::errors::APIError>) -> Self {
                let datalen = v.len();
                let data = Box::into_raw(v.into_boxed_slice());
                Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
@@ -4015,14 +3953,14 @@ impl From<Vec<crate::lightning::util::events::MessageSendEvent>> for CVec_Messag
 }
 #[no_mangle]
 /// Frees the buffer pointed to by `data` if `datalen` is non-0.
-pub extern "C" fn CVec_MessageSendEventZ_free(_res: CVec_MessageSendEventZ) { }
-impl Drop for CVec_MessageSendEventZ {
+pub extern "C" fn CVec_APIErrorZ_free(_res: CVec_APIErrorZ) { }
+impl Drop for CVec_APIErrorZ {
        fn drop(&mut self) {
                if self.datalen == 0 { return; }
                unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
        }
 }
-impl Clone for CVec_MessageSendEventZ {
+impl Clone for CVec_APIErrorZ {
        fn clone(&self) -> Self {
                let mut res = Vec::new();
                if self.datalen == 0 { return Self::from(res); }
@@ -4031,55 +3969,51 @@ impl Clone for CVec_MessageSendEventZ {
        }
 }
 #[repr(C)]
-/// The contents of CResult_boolLightningErrorZ
-pub union CResult_boolLightningErrorZPtr {
-       /// A pointer to the contents in the success state.
-       /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut bool,
+/// The contents of CResult_NonePaymentSendFailureZ
+pub union CResult_NonePaymentSendFailureZPtr {
+       /// Note that this value is always NULL, as there are no contents in the OK variant
+       pub result: *mut std::ffi::c_void,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::lightning::ln::msgs::LightningError,
+       pub err: *mut crate::lightning::ln::channelmanager::PaymentSendFailure,
 }
 #[repr(C)]
-/// A CResult_boolLightningErrorZ represents the result of a fallible operation,
-/// containing a bool on success and a crate::lightning::ln::msgs::LightningError on failure.
+/// A CResult_NonePaymentSendFailureZ represents the result of a fallible operation,
+/// containing a () on success and a crate::lightning::ln::channelmanager::PaymentSendFailure on failure.
 /// `result_ok` indicates the overall state, and the contents are provided via `contents`.
-pub struct CResult_boolLightningErrorZ {
-       /// The contents of this CResult_boolLightningErrorZ, accessible via either
+pub struct CResult_NonePaymentSendFailureZ {
+       /// The contents of this CResult_NonePaymentSendFailureZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_boolLightningErrorZPtr,
-       /// Whether this CResult_boolLightningErrorZ represents a success state.
+       pub contents: CResult_NonePaymentSendFailureZPtr,
+       /// Whether this CResult_NonePaymentSendFailureZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_boolLightningErrorZ in the success state.
-pub extern "C" fn CResult_boolLightningErrorZ_ok(o: bool) -> CResult_boolLightningErrorZ {
-       CResult_boolLightningErrorZ {
-               contents: CResult_boolLightningErrorZPtr {
-                       result: Box::into_raw(Box::new(o)),
+/// Creates a new CResult_NonePaymentSendFailureZ in the success state.
+pub extern "C" fn CResult_NonePaymentSendFailureZ_ok() -> CResult_NonePaymentSendFailureZ {
+       CResult_NonePaymentSendFailureZ {
+               contents: CResult_NonePaymentSendFailureZPtr {
+                       result: std::ptr::null_mut(),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_boolLightningErrorZ in the error state.
-pub extern "C" fn CResult_boolLightningErrorZ_err(e: crate::lightning::ln::msgs::LightningError) -> CResult_boolLightningErrorZ {
-       CResult_boolLightningErrorZ {
-               contents: CResult_boolLightningErrorZPtr {
+/// Creates a new CResult_NonePaymentSendFailureZ in the error state.
+pub extern "C" fn CResult_NonePaymentSendFailureZ_err(e: crate::lightning::ln::channelmanager::PaymentSendFailure) -> CResult_NonePaymentSendFailureZ {
+       CResult_NonePaymentSendFailureZ {
+               contents: CResult_NonePaymentSendFailureZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_boolLightningErrorZ.
-pub extern "C" fn CResult_boolLightningErrorZ_free(_res: CResult_boolLightningErrorZ) { }
-impl Drop for CResult_boolLightningErrorZ {
+/// Frees any resources used by the CResult_NonePaymentSendFailureZ.
+pub extern "C" fn CResult_NonePaymentSendFailureZ_free(_res: CResult_NonePaymentSendFailureZ) { }
+impl Drop for CResult_NonePaymentSendFailureZ {
        fn drop(&mut self) {
                if self.result_ok {
-                       if unsafe { !(self.contents.result as *mut ()).is_null() } {
-                               let _ = unsafe { Box::from_raw(self.contents.result) };
-                       }
                } else {
                        if unsafe { !(self.contents.err as *mut ()).is_null() } {
                                let _ = unsafe { Box::from_raw(self.contents.err) };
@@ -4087,16 +4021,16 @@ impl Drop for CResult_boolLightningErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<bool, crate::lightning::ln::msgs::LightningError>> for CResult_boolLightningErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<bool, crate::lightning::ln::msgs::LightningError>) -> Self {
+impl From<crate::c_types::CResultTempl<(), crate::lightning::ln::channelmanager::PaymentSendFailure>> for CResult_NonePaymentSendFailureZ {
+       fn from(mut o: crate::c_types::CResultTempl<(), crate::lightning::ln::channelmanager::PaymentSendFailure>) -> Self {
                let contents = if o.result_ok {
-                       let result = unsafe { o.contents.result };
-                       unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_boolLightningErrorZPtr { result }
+                       let _ = unsafe { Box::from_raw(o.contents.result) };
+                       o.contents.result = std::ptr::null_mut();
+                       CResult_NonePaymentSendFailureZPtr { result: std::ptr::null_mut() }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_boolLightningErrorZPtr { err }
+                       CResult_NonePaymentSendFailureZPtr { err }
                };
                Self {
                        contents,
@@ -4104,93 +4038,47 @@ impl From<crate::c_types::CResultTempl<bool, crate::lightning::ln::msgs::Lightni
                }
        }
 }
-impl Clone for CResult_boolLightningErrorZ {
+impl Clone for CResult_NonePaymentSendFailureZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_boolLightningErrorZPtr {
-                               result: Box::into_raw(Box::new(<bool>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_NonePaymentSendFailureZPtr {
+                               result: std::ptr::null_mut()
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_boolLightningErrorZPtr {
-                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::LightningError>::clone(unsafe { &*self.contents.err })))
+                       Self { result_ok: false, contents: CResult_NonePaymentSendFailureZPtr {
+                               err: Box::into_raw(Box::new(<crate::lightning::ln::channelmanager::PaymentSendFailure>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_boolLightningErrorZ which has the same data as `orig`
-/// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_boolLightningErrorZ_clone(orig: &CResult_boolLightningErrorZ) -> CResult_boolLightningErrorZ { orig.clone() }
-#[repr(C)]
-/// A tuple of 3 elements. See the individual fields for the types contained.
-pub struct C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ {
-       /// The element at position 0
-       pub a: crate::lightning::ln::msgs::ChannelAnnouncement,
-       /// The element at position 1
-       pub b: crate::lightning::ln::msgs::ChannelUpdate,
-       /// The element at position 2
-       pub c: crate::lightning::ln::msgs::ChannelUpdate,
-}
-impl From<(crate::lightning::ln::msgs::ChannelAnnouncement, crate::lightning::ln::msgs::ChannelUpdate, crate::lightning::ln::msgs::ChannelUpdate)> for C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ {
-       fn from (tup: (crate::lightning::ln::msgs::ChannelAnnouncement, crate::lightning::ln::msgs::ChannelUpdate, crate::lightning::ln::msgs::ChannelUpdate)) -> Self {
-               Self {
-                       a: tup.0,
-                       b: tup.1,
-                       c: tup.2,
-               }
-       }
-}
-impl C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ {
-       #[allow(unused)] pub(crate) fn to_rust(mut self) -> (crate::lightning::ln::msgs::ChannelAnnouncement, crate::lightning::ln::msgs::ChannelUpdate, crate::lightning::ln::msgs::ChannelUpdate) {
-               (self.a, self.b, self.c)
-       }
-}
-impl Clone for C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ {
-       fn clone(&self) -> Self {
-               Self {
-                       a: self.a.clone(),
-                       b: self.b.clone(),
-                       c: self.c.clone(),
-               }
-       }
-}
-#[no_mangle]
-/// Creates a new tuple which has the same data as `orig`
+/// Creates a new CResult_NonePaymentSendFailureZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig: &C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ) -> C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ { orig.clone() }
-/// Creates a new C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ from the contained elements.
-#[no_mangle]
-pub extern "C" fn C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a: crate::lightning::ln::msgs::ChannelAnnouncement, b: crate::lightning::ln::msgs::ChannelUpdate, c: crate::lightning::ln::msgs::ChannelUpdate) -> C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ {
-       C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ { a, b, c, }
-}
-
-#[no_mangle]
-/// Frees any resources used by the C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ.
-pub extern "C" fn C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res: C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ) { }
+pub extern "C" fn CResult_NonePaymentSendFailureZ_clone(orig: &CResult_NonePaymentSendFailureZ) -> CResult_NonePaymentSendFailureZ { orig.clone() }
 #[repr(C)]
-/// A dynamically-allocated array of crate::c_types::derived::C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZs of arbitrary size.
+/// A dynamically-allocated array of crate::lightning::ln::msgs::NetAddresss of arbitrary size.
 /// This corresponds to std::vector in C++
-pub struct CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
+pub struct CVec_NetAddressZ {
        /// The elements in the array.
        /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
-       pub data: *mut crate::c_types::derived::C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ,
+       pub data: *mut crate::lightning::ln::msgs::NetAddress,
        /// The number of elements pointed to by `data`.
        pub datalen: usize
 }
-impl CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
-       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::c_types::derived::C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ> {
+impl CVec_NetAddressZ {
+       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::lightning::ln::msgs::NetAddress> {
                if self.datalen == 0 { return Vec::new(); }
                let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
                self.data = std::ptr::null_mut();
                self.datalen = 0;
                ret
        }
-       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::c_types::derived::C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ] {
+       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::lightning::ln::msgs::NetAddress] {
                unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
        }
 }
-impl From<Vec<crate::c_types::derived::C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ>> for CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
-       fn from(v: Vec<crate::c_types::derived::C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ>) -> Self {
+impl From<Vec<crate::lightning::ln::msgs::NetAddress>> for CVec_NetAddressZ {
+       fn from(v: Vec<crate::lightning::ln::msgs::NetAddress>) -> Self {
                let datalen = v.len();
                let data = Box::into_raw(v.into_boxed_slice());
                Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
@@ -4198,14 +4086,14 @@ impl From<Vec<crate::c_types::derived::C3Tuple_ChannelAnnouncementChannelUpdateC
 }
 #[no_mangle]
 /// Frees the buffer pointed to by `data` if `datalen` is non-0.
-pub extern "C" fn CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res: CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ) { }
-impl Drop for CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
+pub extern "C" fn CVec_NetAddressZ_free(_res: CVec_NetAddressZ) { }
+impl Drop for CVec_NetAddressZ {
        fn drop(&mut self) {
                if self.datalen == 0 { return; }
                unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
        }
 }
-impl Clone for CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
+impl Clone for CVec_NetAddressZ {
        fn clone(&self) -> Self {
                let mut res = Vec::new();
                if self.datalen == 0 { return Self::from(res); }
@@ -4214,97 +4102,97 @@ impl Clone for CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
        }
 }
 #[repr(C)]
-/// A dynamically-allocated array of crate::lightning::ln::msgs::NodeAnnouncements of arbitrary size.
-/// This corresponds to std::vector in C++
-pub struct CVec_NodeAnnouncementZ {
-       /// The elements in the array.
-       /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
-       pub data: *mut crate::lightning::ln::msgs::NodeAnnouncement,
-       /// The number of elements pointed to by `data`.
-       pub datalen: usize
-}
-impl CVec_NodeAnnouncementZ {
-       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::lightning::ln::msgs::NodeAnnouncement> {
-               if self.datalen == 0 { return Vec::new(); }
-               let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
-               self.data = std::ptr::null_mut();
-               self.datalen = 0;
-               ret
-       }
-       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::lightning::ln::msgs::NodeAnnouncement] {
-               unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
-       }
+/// A tuple of 2 elements. See the individual fields for the types contained.
+pub struct C2Tuple_PaymentHashPaymentSecretZ {
+       /// The element at position 0
+       pub a: crate::c_types::ThirtyTwoBytes,
+       /// The element at position 1
+       pub b: crate::c_types::ThirtyTwoBytes,
 }
-impl From<Vec<crate::lightning::ln::msgs::NodeAnnouncement>> for CVec_NodeAnnouncementZ {
-       fn from(v: Vec<crate::lightning::ln::msgs::NodeAnnouncement>) -> Self {
-               let datalen = v.len();
-               let data = Box::into_raw(v.into_boxed_slice());
-               Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
+impl From<(crate::c_types::ThirtyTwoBytes, crate::c_types::ThirtyTwoBytes)> for C2Tuple_PaymentHashPaymentSecretZ {
+       fn from (tup: (crate::c_types::ThirtyTwoBytes, crate::c_types::ThirtyTwoBytes)) -> Self {
+               Self {
+                       a: tup.0,
+                       b: tup.1,
+               }
        }
 }
-#[no_mangle]
-/// Frees the buffer pointed to by `data` if `datalen` is non-0.
-pub extern "C" fn CVec_NodeAnnouncementZ_free(_res: CVec_NodeAnnouncementZ) { }
-impl Drop for CVec_NodeAnnouncementZ {
-       fn drop(&mut self) {
-               if self.datalen == 0 { return; }
-               unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
+impl C2Tuple_PaymentHashPaymentSecretZ {
+       #[allow(unused)] pub(crate) fn to_rust(mut self) -> (crate::c_types::ThirtyTwoBytes, crate::c_types::ThirtyTwoBytes) {
+               (self.a, self.b)
        }
 }
-impl Clone for CVec_NodeAnnouncementZ {
+impl Clone for C2Tuple_PaymentHashPaymentSecretZ {
        fn clone(&self) -> Self {
-               let mut res = Vec::new();
-               if self.datalen == 0 { return Self::from(res); }
-               res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
-               Self::from(res)
+               Self {
+                       a: self.a.clone(),
+                       b: self.b.clone(),
+               }
        }
 }
+#[no_mangle]
+/// Creates a new tuple which has the same data as `orig`
+/// but with all dynamically-allocated buffers duplicated in new buffers.
+pub extern "C" fn C2Tuple_PaymentHashPaymentSecretZ_clone(orig: &C2Tuple_PaymentHashPaymentSecretZ) -> C2Tuple_PaymentHashPaymentSecretZ { orig.clone() }
+/// Creates a new C2Tuple_PaymentHashPaymentSecretZ from the contained elements.
+#[no_mangle]
+pub extern "C" fn C2Tuple_PaymentHashPaymentSecretZ_new(a: crate::c_types::ThirtyTwoBytes, b: crate::c_types::ThirtyTwoBytes) -> C2Tuple_PaymentHashPaymentSecretZ {
+       C2Tuple_PaymentHashPaymentSecretZ { a, b, }
+}
+
+#[no_mangle]
+/// Frees any resources used by the C2Tuple_PaymentHashPaymentSecretZ.
+pub extern "C" fn C2Tuple_PaymentHashPaymentSecretZ_free(_res: C2Tuple_PaymentHashPaymentSecretZ) { }
 #[repr(C)]
-/// The contents of CResult_NoneLightningErrorZ
-pub union CResult_NoneLightningErrorZPtr {
-       /// Note that this value is always NULL, as there are no contents in the OK variant
-       pub result: *mut std::ffi::c_void,
+/// The contents of CResult_PaymentSecretAPIErrorZ
+pub union CResult_PaymentSecretAPIErrorZPtr {
+       /// A pointer to the contents in the success state.
+       /// Reading from this pointer when `result_ok` is not set is undefined.
+       pub result: *mut crate::c_types::ThirtyTwoBytes,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::lightning::ln::msgs::LightningError,
+       pub err: *mut crate::lightning::util::errors::APIError,
 }
 #[repr(C)]
-/// A CResult_NoneLightningErrorZ represents the result of a fallible operation,
-/// containing a () on success and a crate::lightning::ln::msgs::LightningError on failure.
+/// A CResult_PaymentSecretAPIErrorZ represents the result of a fallible operation,
+/// containing a crate::c_types::ThirtyTwoBytes on success and a crate::lightning::util::errors::APIError on failure.
 /// `result_ok` indicates the overall state, and the contents are provided via `contents`.
-pub struct CResult_NoneLightningErrorZ {
-       /// The contents of this CResult_NoneLightningErrorZ, accessible via either
+pub struct CResult_PaymentSecretAPIErrorZ {
+       /// The contents of this CResult_PaymentSecretAPIErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_NoneLightningErrorZPtr,
-       /// Whether this CResult_NoneLightningErrorZ represents a success state.
+       pub contents: CResult_PaymentSecretAPIErrorZPtr,
+       /// Whether this CResult_PaymentSecretAPIErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_NoneLightningErrorZ in the success state.
-pub extern "C" fn CResult_NoneLightningErrorZ_ok() -> CResult_NoneLightningErrorZ {
-       CResult_NoneLightningErrorZ {
-               contents: CResult_NoneLightningErrorZPtr {
-                       result: std::ptr::null_mut(),
+/// Creates a new CResult_PaymentSecretAPIErrorZ in the success state.
+pub extern "C" fn CResult_PaymentSecretAPIErrorZ_ok(o: crate::c_types::ThirtyTwoBytes) -> CResult_PaymentSecretAPIErrorZ {
+       CResult_PaymentSecretAPIErrorZ {
+               contents: CResult_PaymentSecretAPIErrorZPtr {
+                       result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_NoneLightningErrorZ in the error state.
-pub extern "C" fn CResult_NoneLightningErrorZ_err(e: crate::lightning::ln::msgs::LightningError) -> CResult_NoneLightningErrorZ {
-       CResult_NoneLightningErrorZ {
-               contents: CResult_NoneLightningErrorZPtr {
+/// Creates a new CResult_PaymentSecretAPIErrorZ in the error state.
+pub extern "C" fn CResult_PaymentSecretAPIErrorZ_err(e: crate::lightning::util::errors::APIError) -> CResult_PaymentSecretAPIErrorZ {
+       CResult_PaymentSecretAPIErrorZ {
+               contents: CResult_PaymentSecretAPIErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_NoneLightningErrorZ.
-pub extern "C" fn CResult_NoneLightningErrorZ_free(_res: CResult_NoneLightningErrorZ) { }
-impl Drop for CResult_NoneLightningErrorZ {
+/// Frees any resources used by the CResult_PaymentSecretAPIErrorZ.
+pub extern "C" fn CResult_PaymentSecretAPIErrorZ_free(_res: CResult_PaymentSecretAPIErrorZ) { }
+impl Drop for CResult_PaymentSecretAPIErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
+                       if unsafe { !(self.contents.result as *mut ()).is_null() } {
+                               let _ = unsafe { Box::from_raw(self.contents.result) };
+                       }
                } else {
                        if unsafe { !(self.contents.err as *mut ()).is_null() } {
                                let _ = unsafe { Box::from_raw(self.contents.err) };
@@ -4312,16 +4200,16 @@ impl Drop for CResult_NoneLightningErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<(), crate::lightning::ln::msgs::LightningError>> for CResult_NoneLightningErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<(), crate::lightning::ln::msgs::LightningError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::c_types::ThirtyTwoBytes, crate::lightning::util::errors::APIError>> for CResult_PaymentSecretAPIErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::c_types::ThirtyTwoBytes, crate::lightning::util::errors::APIError>) -> Self {
                let contents = if o.result_ok {
-                       let _ = unsafe { Box::from_raw(o.contents.result) };
-                       o.contents.result = std::ptr::null_mut();
-                       CResult_NoneLightningErrorZPtr { result: std::ptr::null_mut() }
+                       let result = unsafe { o.contents.result };
+                       unsafe { o.contents.result = std::ptr::null_mut() };
+                       CResult_PaymentSecretAPIErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_NoneLightningErrorZPtr { err }
+                       CResult_PaymentSecretAPIErrorZPtr { err }
                };
                Self {
                        contents,
@@ -4329,47 +4217,47 @@ impl From<crate::c_types::CResultTempl<(), crate::lightning::ln::msgs::Lightning
                }
        }
 }
-impl Clone for CResult_NoneLightningErrorZ {
+impl Clone for CResult_PaymentSecretAPIErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_NoneLightningErrorZPtr {
-                               result: std::ptr::null_mut()
+                       Self { result_ok: true, contents: CResult_PaymentSecretAPIErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::c_types::ThirtyTwoBytes>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_NoneLightningErrorZPtr {
-                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::LightningError>::clone(unsafe { &*self.contents.err })))
+                       Self { result_ok: false, contents: CResult_PaymentSecretAPIErrorZPtr {
+                               err: Box::into_raw(Box::new(<crate::lightning::util::errors::APIError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_NoneLightningErrorZ which has the same data as `orig`
+/// Creates a new CResult_PaymentSecretAPIErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_NoneLightningErrorZ_clone(orig: &CResult_NoneLightningErrorZ) -> CResult_NoneLightningErrorZ { orig.clone() }
+pub extern "C" fn CResult_PaymentSecretAPIErrorZ_clone(orig: &CResult_PaymentSecretAPIErrorZ) -> CResult_PaymentSecretAPIErrorZ { orig.clone() }
 #[repr(C)]
-/// A dynamically-allocated array of crate::c_types::PublicKeys of arbitrary size.
+/// A dynamically-allocated array of crate::lightning::chain::channelmonitor::ChannelMonitors of arbitrary size.
 /// This corresponds to std::vector in C++
-pub struct CVec_PublicKeyZ {
+pub struct CVec_ChannelMonitorZ {
        /// The elements in the array.
        /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
-       pub data: *mut crate::c_types::PublicKey,
+       pub data: *mut crate::lightning::chain::channelmonitor::ChannelMonitor,
        /// The number of elements pointed to by `data`.
        pub datalen: usize
 }
-impl CVec_PublicKeyZ {
-       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::c_types::PublicKey> {
+impl CVec_ChannelMonitorZ {
+       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::lightning::chain::channelmonitor::ChannelMonitor> {
                if self.datalen == 0 { return Vec::new(); }
                let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
                self.data = std::ptr::null_mut();
                self.datalen = 0;
                ret
        }
-       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::c_types::PublicKey] {
+       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::lightning::chain::channelmonitor::ChannelMonitor] {
                unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
        }
 }
-impl From<Vec<crate::c_types::PublicKey>> for CVec_PublicKeyZ {
-       fn from(v: Vec<crate::c_types::PublicKey>) -> Self {
+impl From<Vec<crate::lightning::chain::channelmonitor::ChannelMonitor>> for CVec_ChannelMonitorZ {
+       fn from(v: Vec<crate::lightning::chain::channelmonitor::ChannelMonitor>) -> Self {
                let datalen = v.len();
                let data = Box::into_raw(v.into_boxed_slice());
                Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
@@ -4377,58 +4265,88 @@ impl From<Vec<crate::c_types::PublicKey>> for CVec_PublicKeyZ {
 }
 #[no_mangle]
 /// Frees the buffer pointed to by `data` if `datalen` is non-0.
-pub extern "C" fn CVec_PublicKeyZ_free(_res: CVec_PublicKeyZ) { }
-impl Drop for CVec_PublicKeyZ {
+pub extern "C" fn CVec_ChannelMonitorZ_free(_res: CVec_ChannelMonitorZ) { }
+impl Drop for CVec_ChannelMonitorZ {
        fn drop(&mut self) {
                if self.datalen == 0 { return; }
                unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
        }
 }
 #[repr(C)]
-/// The contents of CResult_CVec_u8ZPeerHandleErrorZ
-pub union CResult_CVec_u8ZPeerHandleErrorZPtr {
+/// A tuple of 2 elements. See the individual fields for the types contained.
+pub struct C2Tuple_BlockHashChannelManagerZ {
+       /// The element at position 0
+       pub a: crate::c_types::ThirtyTwoBytes,
+       /// The element at position 1
+       pub b: crate::lightning::ln::channelmanager::ChannelManager,
+}
+impl From<(crate::c_types::ThirtyTwoBytes, crate::lightning::ln::channelmanager::ChannelManager)> for C2Tuple_BlockHashChannelManagerZ {
+       fn from (tup: (crate::c_types::ThirtyTwoBytes, crate::lightning::ln::channelmanager::ChannelManager)) -> Self {
+               Self {
+                       a: tup.0,
+                       b: tup.1,
+               }
+       }
+}
+impl C2Tuple_BlockHashChannelManagerZ {
+       #[allow(unused)] pub(crate) fn to_rust(mut self) -> (crate::c_types::ThirtyTwoBytes, crate::lightning::ln::channelmanager::ChannelManager) {
+               (self.a, self.b)
+       }
+}
+/// Creates a new C2Tuple_BlockHashChannelManagerZ from the contained elements.
+#[no_mangle]
+pub extern "C" fn C2Tuple_BlockHashChannelManagerZ_new(a: crate::c_types::ThirtyTwoBytes, b: crate::lightning::ln::channelmanager::ChannelManager) -> C2Tuple_BlockHashChannelManagerZ {
+       C2Tuple_BlockHashChannelManagerZ { a, b, }
+}
+
+#[no_mangle]
+/// Frees any resources used by the C2Tuple_BlockHashChannelManagerZ.
+pub extern "C" fn C2Tuple_BlockHashChannelManagerZ_free(_res: C2Tuple_BlockHashChannelManagerZ) { }
+#[repr(C)]
+/// The contents of CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ
+pub union CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::c_types::derived::CVec_u8Z,
+       pub result: *mut crate::c_types::derived::C2Tuple_BlockHashChannelManagerZ,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::lightning::ln::peer_handler::PeerHandleError,
+       pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// 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.
+/// 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.
 /// `result_ok` indicates the overall state, and the contents are provided via `contents`.
-pub struct CResult_CVec_u8ZPeerHandleErrorZ {
-       /// The contents of this CResult_CVec_u8ZPeerHandleErrorZ, accessible via either
+pub struct CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ {
+       /// The contents of this CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_CVec_u8ZPeerHandleErrorZPtr,
-       /// Whether this CResult_CVec_u8ZPeerHandleErrorZ represents a success state.
+       pub contents: CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZPtr,
+       /// Whether this CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_CVec_u8ZPeerHandleErrorZ in the success state.
-pub extern "C" fn CResult_CVec_u8ZPeerHandleErrorZ_ok(o: crate::c_types::derived::CVec_u8Z) -> CResult_CVec_u8ZPeerHandleErrorZ {
-       CResult_CVec_u8ZPeerHandleErrorZ {
-               contents: CResult_CVec_u8ZPeerHandleErrorZPtr {
+/// Creates a new CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ in the success state.
+pub extern "C" fn CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o: crate::c_types::derived::C2Tuple_BlockHashChannelManagerZ) -> CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ {
+       CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ {
+               contents: CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_CVec_u8ZPeerHandleErrorZ in the error state.
-pub extern "C" fn CResult_CVec_u8ZPeerHandleErrorZ_err(e: crate::lightning::ln::peer_handler::PeerHandleError) -> CResult_CVec_u8ZPeerHandleErrorZ {
-       CResult_CVec_u8ZPeerHandleErrorZ {
-               contents: CResult_CVec_u8ZPeerHandleErrorZPtr {
+/// Creates a new CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ in the error state.
+pub extern "C" fn CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ {
+       CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ {
+               contents: CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_CVec_u8ZPeerHandleErrorZ.
-pub extern "C" fn CResult_CVec_u8ZPeerHandleErrorZ_free(_res: CResult_CVec_u8ZPeerHandleErrorZ) { }
-impl Drop for CResult_CVec_u8ZPeerHandleErrorZ {
+/// Frees any resources used by the CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ.
+pub extern "C" fn CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res: CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ) { }
+impl Drop for CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -4441,16 +4359,16 @@ impl Drop for CResult_CVec_u8ZPeerHandleErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::c_types::derived::CVec_u8Z, crate::lightning::ln::peer_handler::PeerHandleError>> for CResult_CVec_u8ZPeerHandleErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::c_types::derived::CVec_u8Z, crate::lightning::ln::peer_handler::PeerHandleError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::c_types::derived::C2Tuple_BlockHashChannelManagerZ, crate::lightning::ln::msgs::DecodeError>> for CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::c_types::derived::C2Tuple_BlockHashChannelManagerZ, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_CVec_u8ZPeerHandleErrorZPtr { result }
+                       CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_CVec_u8ZPeerHandleErrorZPtr { err }
+                       CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -4458,69 +4376,56 @@ impl From<crate::c_types::CResultTempl<crate::c_types::derived::CVec_u8Z, crate:
                }
        }
 }
-impl Clone for CResult_CVec_u8ZPeerHandleErrorZ {
-       fn clone(&self) -> Self {
-               if self.result_ok {
-                       Self { result_ok: true, contents: CResult_CVec_u8ZPeerHandleErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::c_types::derived::CVec_u8Z>::clone(unsafe { &*self.contents.result })))
-                       } }
-               } else {
-                       Self { result_ok: false, contents: CResult_CVec_u8ZPeerHandleErrorZPtr {
-                               err: Box::into_raw(Box::new(<crate::lightning::ln::peer_handler::PeerHandleError>::clone(unsafe { &*self.contents.err })))
-                       } }
-               }
-       }
-}
-#[no_mangle]
-/// Creates a new CResult_CVec_u8ZPeerHandleErrorZ which has the same data as `orig`
-/// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_CVec_u8ZPeerHandleErrorZ_clone(orig: &CResult_CVec_u8ZPeerHandleErrorZ) -> CResult_CVec_u8ZPeerHandleErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_NonePeerHandleErrorZ
-pub union CResult_NonePeerHandleErrorZPtr {
-       /// Note that this value is always NULL, as there are no contents in the OK variant
-       pub result: *mut std::ffi::c_void,
+/// The contents of CResult_ChannelConfigDecodeErrorZ
+pub union CResult_ChannelConfigDecodeErrorZPtr {
+       /// A pointer to the contents in the success state.
+       /// Reading from this pointer when `result_ok` is not set is undefined.
+       pub result: *mut crate::lightning::util::config::ChannelConfig,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::lightning::ln::peer_handler::PeerHandleError,
+       pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// A CResult_NonePeerHandleErrorZ represents the result of a fallible operation,
-/// containing a () on success and a crate::lightning::ln::peer_handler::PeerHandleError on failure.
+/// A CResult_ChannelConfigDecodeErrorZ represents the result of a fallible operation,
+/// containing a crate::lightning::util::config::ChannelConfig on success and a crate::lightning::ln::msgs::DecodeError on failure.
 /// `result_ok` indicates the overall state, and the contents are provided via `contents`.
-pub struct CResult_NonePeerHandleErrorZ {
-       /// The contents of this CResult_NonePeerHandleErrorZ, accessible via either
+pub struct CResult_ChannelConfigDecodeErrorZ {
+       /// The contents of this CResult_ChannelConfigDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_NonePeerHandleErrorZPtr,
-       /// Whether this CResult_NonePeerHandleErrorZ represents a success state.
+       pub contents: CResult_ChannelConfigDecodeErrorZPtr,
+       /// Whether this CResult_ChannelConfigDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_NonePeerHandleErrorZ in the success state.
-pub extern "C" fn CResult_NonePeerHandleErrorZ_ok() -> CResult_NonePeerHandleErrorZ {
-       CResult_NonePeerHandleErrorZ {
-               contents: CResult_NonePeerHandleErrorZPtr {
-                       result: std::ptr::null_mut(),
+/// Creates a new CResult_ChannelConfigDecodeErrorZ in the success state.
+pub extern "C" fn CResult_ChannelConfigDecodeErrorZ_ok(o: crate::lightning::util::config::ChannelConfig) -> CResult_ChannelConfigDecodeErrorZ {
+       CResult_ChannelConfigDecodeErrorZ {
+               contents: CResult_ChannelConfigDecodeErrorZPtr {
+                       result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_NonePeerHandleErrorZ in the error state.
-pub extern "C" fn CResult_NonePeerHandleErrorZ_err(e: crate::lightning::ln::peer_handler::PeerHandleError) -> CResult_NonePeerHandleErrorZ {
-       CResult_NonePeerHandleErrorZ {
-               contents: CResult_NonePeerHandleErrorZPtr {
+/// Creates a new CResult_ChannelConfigDecodeErrorZ in the error state.
+pub extern "C" fn CResult_ChannelConfigDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_ChannelConfigDecodeErrorZ {
+       CResult_ChannelConfigDecodeErrorZ {
+               contents: CResult_ChannelConfigDecodeErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_NonePeerHandleErrorZ.
-pub extern "C" fn CResult_NonePeerHandleErrorZ_free(_res: CResult_NonePeerHandleErrorZ) { }
-impl Drop for CResult_NonePeerHandleErrorZ {
+/// Frees any resources used by the CResult_ChannelConfigDecodeErrorZ.
+pub extern "C" fn CResult_ChannelConfigDecodeErrorZ_free(_res: CResult_ChannelConfigDecodeErrorZ) { }
+impl Drop for CResult_ChannelConfigDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
+                       if unsafe { !(self.contents.result as *mut ()).is_null() } {
+                               let _ = unsafe { Box::from_raw(self.contents.result) };
+                       }
                } else {
                        if unsafe { !(self.contents.err as *mut ()).is_null() } {
                                let _ = unsafe { Box::from_raw(self.contents.err) };
@@ -4528,16 +4433,16 @@ impl Drop for CResult_NonePeerHandleErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<(), crate::lightning::ln::peer_handler::PeerHandleError>> for CResult_NonePeerHandleErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<(), crate::lightning::ln::peer_handler::PeerHandleError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::util::config::ChannelConfig, crate::lightning::ln::msgs::DecodeError>> for CResult_ChannelConfigDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::util::config::ChannelConfig, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
-                       let _ = unsafe { Box::from_raw(o.contents.result) };
-                       o.contents.result = std::ptr::null_mut();
-                       CResult_NonePeerHandleErrorZPtr { result: std::ptr::null_mut() }
+                       let result = unsafe { o.contents.result };
+                       unsafe { o.contents.result = std::ptr::null_mut() };
+                       CResult_ChannelConfigDecodeErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_NonePeerHandleErrorZPtr { err }
+                       CResult_ChannelConfigDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -4545,68 +4450,68 @@ impl From<crate::c_types::CResultTempl<(), crate::lightning::ln::peer_handler::P
                }
        }
 }
-impl Clone for CResult_NonePeerHandleErrorZ {
+impl Clone for CResult_ChannelConfigDecodeErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_NonePeerHandleErrorZPtr {
-                               result: std::ptr::null_mut()
+                       Self { result_ok: true, contents: CResult_ChannelConfigDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::util::config::ChannelConfig>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_NonePeerHandleErrorZPtr {
-                               err: Box::into_raw(Box::new(<crate::lightning::ln::peer_handler::PeerHandleError>::clone(unsafe { &*self.contents.err })))
+                       Self { result_ok: false, contents: CResult_ChannelConfigDecodeErrorZPtr {
+                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_NonePeerHandleErrorZ which has the same data as `orig`
+/// Creates a new CResult_ChannelConfigDecodeErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_NonePeerHandleErrorZ_clone(orig: &CResult_NonePeerHandleErrorZ) -> CResult_NonePeerHandleErrorZ { orig.clone() }
+pub extern "C" fn CResult_ChannelConfigDecodeErrorZ_clone(orig: &CResult_ChannelConfigDecodeErrorZ) -> CResult_ChannelConfigDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_boolPeerHandleErrorZ
-pub union CResult_boolPeerHandleErrorZPtr {
+/// The contents of CResult_OutPointDecodeErrorZ
+pub union CResult_OutPointDecodeErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut bool,
+       pub result: *mut crate::lightning::chain::transaction::OutPoint,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::lightning::ln::peer_handler::PeerHandleError,
+       pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// 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.
+/// A CResult_OutPointDecodeErrorZ represents the result of a fallible operation,
+/// containing a crate::lightning::chain::transaction::OutPoint on success and a crate::lightning::ln::msgs::DecodeError on failure.
 /// `result_ok` indicates the overall state, and the contents are provided via `contents`.
-pub struct CResult_boolPeerHandleErrorZ {
-       /// The contents of this CResult_boolPeerHandleErrorZ, accessible via either
+pub struct CResult_OutPointDecodeErrorZ {
+       /// The contents of this CResult_OutPointDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_boolPeerHandleErrorZPtr,
-       /// Whether this CResult_boolPeerHandleErrorZ represents a success state.
+       pub contents: CResult_OutPointDecodeErrorZPtr,
+       /// Whether this CResult_OutPointDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_boolPeerHandleErrorZ in the success state.
-pub extern "C" fn CResult_boolPeerHandleErrorZ_ok(o: bool) -> CResult_boolPeerHandleErrorZ {
-       CResult_boolPeerHandleErrorZ {
-               contents: CResult_boolPeerHandleErrorZPtr {
+/// Creates a new CResult_OutPointDecodeErrorZ in the success state.
+pub extern "C" fn CResult_OutPointDecodeErrorZ_ok(o: crate::lightning::chain::transaction::OutPoint) -> CResult_OutPointDecodeErrorZ {
+       CResult_OutPointDecodeErrorZ {
+               contents: CResult_OutPointDecodeErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_boolPeerHandleErrorZ in the error state.
-pub extern "C" fn CResult_boolPeerHandleErrorZ_err(e: crate::lightning::ln::peer_handler::PeerHandleError) -> CResult_boolPeerHandleErrorZ {
-       CResult_boolPeerHandleErrorZ {
-               contents: CResult_boolPeerHandleErrorZPtr {
+/// Creates a new CResult_OutPointDecodeErrorZ in the error state.
+pub extern "C" fn CResult_OutPointDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_OutPointDecodeErrorZ {
+       CResult_OutPointDecodeErrorZ {
+               contents: CResult_OutPointDecodeErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_boolPeerHandleErrorZ.
-pub extern "C" fn CResult_boolPeerHandleErrorZ_free(_res: CResult_boolPeerHandleErrorZ) { }
-impl Drop for CResult_boolPeerHandleErrorZ {
+/// Frees any resources used by the CResult_OutPointDecodeErrorZ.
+pub extern "C" fn CResult_OutPointDecodeErrorZ_free(_res: CResult_OutPointDecodeErrorZ) { }
+impl Drop for CResult_OutPointDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -4619,16 +4524,16 @@ impl Drop for CResult_boolPeerHandleErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<bool, crate::lightning::ln::peer_handler::PeerHandleError>> for CResult_boolPeerHandleErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<bool, crate::lightning::ln::peer_handler::PeerHandleError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::chain::transaction::OutPoint, crate::lightning::ln::msgs::DecodeError>> for CResult_OutPointDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::chain::transaction::OutPoint, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_boolPeerHandleErrorZPtr { result }
+                       CResult_OutPointDecodeErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_boolPeerHandleErrorZPtr { err }
+                       CResult_OutPointDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -4636,90 +4541,86 @@ impl From<crate::c_types::CResultTempl<bool, crate::lightning::ln::peer_handler:
                }
        }
 }
-impl Clone for CResult_boolPeerHandleErrorZ {
+impl Clone for CResult_OutPointDecodeErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_boolPeerHandleErrorZPtr {
-                               result: Box::into_raw(Box::new(<bool>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_OutPointDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::chain::transaction::OutPoint>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_boolPeerHandleErrorZPtr {
-                               err: Box::into_raw(Box::new(<crate::lightning::ln::peer_handler::PeerHandleError>::clone(unsafe { &*self.contents.err })))
+                       Self { result_ok: false, contents: CResult_OutPointDecodeErrorZPtr {
+                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_boolPeerHandleErrorZ which has the same data as `orig`
+/// Creates a new CResult_OutPointDecodeErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_boolPeerHandleErrorZ_clone(orig: &CResult_boolPeerHandleErrorZ) -> CResult_boolPeerHandleErrorZ { orig.clone() }
+pub extern "C" fn CResult_OutPointDecodeErrorZ_clone(orig: &CResult_OutPointDecodeErrorZ) -> CResult_OutPointDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_TxOutAccessErrorZ
-pub union CResult_TxOutAccessErrorZPtr {
+/// The contents of CResult_SiPrefixNoneZ
+pub union CResult_SiPrefixNoneZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::c_types::TxOut,
-       /// A pointer to the contents in the error state.
-       /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::lightning::chain::AccessError,
+       pub result: *mut crate::lightning_invoice::SiPrefix,
+       /// Note that this value is always NULL, as there are no contents in the Err variant
+       pub err: *mut std::ffi::c_void,
 }
 #[repr(C)]
-/// 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.
+/// A CResult_SiPrefixNoneZ represents the result of a fallible operation,
+/// containing a crate::lightning_invoice::SiPrefix on success and a () on failure.
 /// `result_ok` indicates the overall state, and the contents are provided via `contents`.
-pub struct CResult_TxOutAccessErrorZ {
-       /// The contents of this CResult_TxOutAccessErrorZ, accessible via either
+pub struct CResult_SiPrefixNoneZ {
+       /// The contents of this CResult_SiPrefixNoneZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_TxOutAccessErrorZPtr,
-       /// Whether this CResult_TxOutAccessErrorZ represents a success state.
+       pub contents: CResult_SiPrefixNoneZPtr,
+       /// Whether this CResult_SiPrefixNoneZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_TxOutAccessErrorZ in the success state.
-pub extern "C" fn CResult_TxOutAccessErrorZ_ok(o: crate::c_types::TxOut) -> CResult_TxOutAccessErrorZ {
-       CResult_TxOutAccessErrorZ {
-               contents: CResult_TxOutAccessErrorZPtr {
+/// Creates a new CResult_SiPrefixNoneZ in the success state.
+pub extern "C" fn CResult_SiPrefixNoneZ_ok(o: crate::lightning_invoice::SiPrefix) -> CResult_SiPrefixNoneZ {
+       CResult_SiPrefixNoneZ {
+               contents: CResult_SiPrefixNoneZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_TxOutAccessErrorZ in the error state.
-pub extern "C" fn CResult_TxOutAccessErrorZ_err(e: crate::lightning::chain::AccessError) -> CResult_TxOutAccessErrorZ {
-       CResult_TxOutAccessErrorZ {
-               contents: CResult_TxOutAccessErrorZPtr {
-                       err: Box::into_raw(Box::new(e)),
+/// Creates a new CResult_SiPrefixNoneZ in the error state.
+pub extern "C" fn CResult_SiPrefixNoneZ_err() -> CResult_SiPrefixNoneZ {
+       CResult_SiPrefixNoneZ {
+               contents: CResult_SiPrefixNoneZPtr {
+                       err: std::ptr::null_mut(),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_TxOutAccessErrorZ.
-pub extern "C" fn CResult_TxOutAccessErrorZ_free(_res: CResult_TxOutAccessErrorZ) { }
-impl Drop for CResult_TxOutAccessErrorZ {
+/// Frees any resources used by the CResult_SiPrefixNoneZ.
+pub extern "C" fn CResult_SiPrefixNoneZ_free(_res: CResult_SiPrefixNoneZ) { }
+impl Drop for CResult_SiPrefixNoneZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
                                let _ = unsafe { Box::from_raw(self.contents.result) };
                        }
                } else {
-                       if unsafe { !(self.contents.err as *mut ()).is_null() } {
-                               let _ = unsafe { Box::from_raw(self.contents.err) };
-                       }
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::c_types::TxOut, crate::lightning::chain::AccessError>> for CResult_TxOutAccessErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::c_types::TxOut, crate::lightning::chain::AccessError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning_invoice::SiPrefix, ()>> for CResult_SiPrefixNoneZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning_invoice::SiPrefix, ()>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_TxOutAccessErrorZPtr { result }
+                       CResult_SiPrefixNoneZPtr { result }
                } else {
-                       let err = unsafe { o.contents.err };
-                       unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_TxOutAccessErrorZPtr { err }
+                       let _ = unsafe { Box::from_raw(o.contents.err) };
+                       o.contents.err = std::ptr::null_mut();
+                       CResult_SiPrefixNoneZPtr { err: std::ptr::null_mut() }
                };
                Self {
                        contents,
@@ -4727,165 +4628,86 @@ impl From<crate::c_types::CResultTempl<crate::c_types::TxOut, crate::lightning::
                }
        }
 }
-impl Clone for CResult_TxOutAccessErrorZ {
+impl Clone for CResult_SiPrefixNoneZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_TxOutAccessErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::c_types::TxOut>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_SiPrefixNoneZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning_invoice::SiPrefix>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_TxOutAccessErrorZPtr {
-                               err: Box::into_raw(Box::new(<crate::lightning::chain::AccessError>::clone(unsafe { &*self.contents.err })))
+                       Self { result_ok: false, contents: CResult_SiPrefixNoneZPtr {
+                               err: std::ptr::null_mut()
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_TxOutAccessErrorZ which has the same data as `orig`
+/// Creates a new CResult_SiPrefixNoneZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_TxOutAccessErrorZ_clone(orig: &CResult_TxOutAccessErrorZ) -> CResult_TxOutAccessErrorZ { orig.clone() }
-#[repr(C)]
-/// An enum which can either contain a crate::c_types::derived::C2Tuple_usizeTransactionZ or not
-pub enum COption_C2Tuple_usizeTransactionZZ {
-       /// When we're in this state, this COption_C2Tuple_usizeTransactionZZ contains a crate::c_types::derived::C2Tuple_usizeTransactionZ
-       Some(crate::c_types::derived::C2Tuple_usizeTransactionZ),
-       /// When we're in this state, this COption_C2Tuple_usizeTransactionZZ contains nothing
-       None
-}
-impl COption_C2Tuple_usizeTransactionZZ {
-       #[allow(unused)] pub(crate) fn is_some(&self) -> bool {
-               if let Self::Some(_) = self { true } else { false }
-       }
-       #[allow(unused)] pub(crate) fn take(mut self) -> crate::c_types::derived::C2Tuple_usizeTransactionZ {
-               if let Self::Some(v) = self { v } else { unreachable!() }
-       }
-}
-#[no_mangle]
-/// Constructs a new COption_C2Tuple_usizeTransactionZZ containing a crate::c_types::derived::C2Tuple_usizeTransactionZ
-pub extern "C" fn COption_C2Tuple_usizeTransactionZZ_some(o: crate::c_types::derived::C2Tuple_usizeTransactionZ) -> COption_C2Tuple_usizeTransactionZZ {
-       COption_C2Tuple_usizeTransactionZZ::Some(o)
-}
-#[no_mangle]
-/// Constructs a new COption_C2Tuple_usizeTransactionZZ containing nothing
-pub extern "C" fn COption_C2Tuple_usizeTransactionZZ_none() -> COption_C2Tuple_usizeTransactionZZ {
-       COption_C2Tuple_usizeTransactionZZ::None
-}
-#[no_mangle]
-/// Frees any resources associated with the crate::c_types::derived::C2Tuple_usizeTransactionZ, if we are in the Some state
-pub extern "C" fn COption_C2Tuple_usizeTransactionZZ_free(_res: COption_C2Tuple_usizeTransactionZZ) { }
-#[repr(C)]
-/// A dynamically-allocated array of crate::lightning::chain::keysinterface::SpendableOutputDescriptors of arbitrary size.
-/// This corresponds to std::vector in C++
-pub struct CVec_SpendableOutputDescriptorZ {
-       /// The elements in the array.
-       /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
-       pub data: *mut crate::lightning::chain::keysinterface::SpendableOutputDescriptor,
-       /// The number of elements pointed to by `data`.
-       pub datalen: usize
-}
-impl CVec_SpendableOutputDescriptorZ {
-       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::lightning::chain::keysinterface::SpendableOutputDescriptor> {
-               if self.datalen == 0 { return Vec::new(); }
-               let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
-               self.data = std::ptr::null_mut();
-               self.datalen = 0;
-               ret
-       }
-       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::lightning::chain::keysinterface::SpendableOutputDescriptor] {
-               unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
-       }
-}
-impl From<Vec<crate::lightning::chain::keysinterface::SpendableOutputDescriptor>> for CVec_SpendableOutputDescriptorZ {
-       fn from(v: Vec<crate::lightning::chain::keysinterface::SpendableOutputDescriptor>) -> Self {
-               let datalen = v.len();
-               let data = Box::into_raw(v.into_boxed_slice());
-               Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
-       }
-}
-#[no_mangle]
-/// Frees the buffer pointed to by `data` if `datalen` is non-0.
-pub extern "C" fn CVec_SpendableOutputDescriptorZ_free(_res: CVec_SpendableOutputDescriptorZ) { }
-impl Drop for CVec_SpendableOutputDescriptorZ {
-       fn drop(&mut self) {
-               if self.datalen == 0 { return; }
-               unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
-       }
-}
-impl Clone for CVec_SpendableOutputDescriptorZ {
-       fn clone(&self) -> Self {
-               let mut res = Vec::new();
-               if self.datalen == 0 { return Self::from(res); }
-               res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
-               Self::from(res)
-       }
-}
+pub extern "C" fn CResult_SiPrefixNoneZ_clone(orig: &CResult_SiPrefixNoneZ) -> CResult_SiPrefixNoneZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_DirectionalChannelInfoDecodeErrorZ
-pub union CResult_DirectionalChannelInfoDecodeErrorZPtr {
+/// The contents of CResult_InvoiceNoneZ
+pub union CResult_InvoiceNoneZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::routing::network_graph::DirectionalChannelInfo,
-       /// A pointer to the contents in the error state.
-       /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::lightning::ln::msgs::DecodeError,
+       pub result: *mut crate::lightning_invoice::Invoice,
+       /// Note that this value is always NULL, as there are no contents in the Err variant
+       pub err: *mut std::ffi::c_void,
 }
 #[repr(C)]
-/// 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.
+/// A CResult_InvoiceNoneZ represents the result of a fallible operation,
+/// containing a crate::lightning_invoice::Invoice on success and a () on failure.
 /// `result_ok` indicates the overall state, and the contents are provided via `contents`.
-pub struct CResult_DirectionalChannelInfoDecodeErrorZ {
-       /// The contents of this CResult_DirectionalChannelInfoDecodeErrorZ, accessible via either
+pub struct CResult_InvoiceNoneZ {
+       /// The contents of this CResult_InvoiceNoneZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_DirectionalChannelInfoDecodeErrorZPtr,
-       /// Whether this CResult_DirectionalChannelInfoDecodeErrorZ represents a success state.
+       pub contents: CResult_InvoiceNoneZPtr,
+       /// Whether this CResult_InvoiceNoneZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_DirectionalChannelInfoDecodeErrorZ in the success state.
-pub extern "C" fn CResult_DirectionalChannelInfoDecodeErrorZ_ok(o: crate::lightning::routing::network_graph::DirectionalChannelInfo) -> CResult_DirectionalChannelInfoDecodeErrorZ {
-       CResult_DirectionalChannelInfoDecodeErrorZ {
-               contents: CResult_DirectionalChannelInfoDecodeErrorZPtr {
+/// Creates a new CResult_InvoiceNoneZ in the success state.
+pub extern "C" fn CResult_InvoiceNoneZ_ok(o: crate::lightning_invoice::Invoice) -> CResult_InvoiceNoneZ {
+       CResult_InvoiceNoneZ {
+               contents: CResult_InvoiceNoneZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_DirectionalChannelInfoDecodeErrorZ in the error state.
-pub extern "C" fn CResult_DirectionalChannelInfoDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_DirectionalChannelInfoDecodeErrorZ {
-       CResult_DirectionalChannelInfoDecodeErrorZ {
-               contents: CResult_DirectionalChannelInfoDecodeErrorZPtr {
-                       err: Box::into_raw(Box::new(e)),
+/// Creates a new CResult_InvoiceNoneZ in the error state.
+pub extern "C" fn CResult_InvoiceNoneZ_err() -> CResult_InvoiceNoneZ {
+       CResult_InvoiceNoneZ {
+               contents: CResult_InvoiceNoneZPtr {
+                       err: std::ptr::null_mut(),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_DirectionalChannelInfoDecodeErrorZ.
-pub extern "C" fn CResult_DirectionalChannelInfoDecodeErrorZ_free(_res: CResult_DirectionalChannelInfoDecodeErrorZ) { }
-impl Drop for CResult_DirectionalChannelInfoDecodeErrorZ {
+/// Frees any resources used by the CResult_InvoiceNoneZ.
+pub extern "C" fn CResult_InvoiceNoneZ_free(_res: CResult_InvoiceNoneZ) { }
+impl Drop for CResult_InvoiceNoneZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
                                let _ = unsafe { Box::from_raw(self.contents.result) };
                        }
                } else {
-                       if unsafe { !(self.contents.err as *mut ()).is_null() } {
-                               let _ = unsafe { Box::from_raw(self.contents.err) };
-                       }
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::routing::network_graph::DirectionalChannelInfo, crate::lightning::ln::msgs::DecodeError>> for CResult_DirectionalChannelInfoDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::routing::network_graph::DirectionalChannelInfo, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning_invoice::Invoice, ()>> for CResult_InvoiceNoneZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning_invoice::Invoice, ()>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_DirectionalChannelInfoDecodeErrorZPtr { result }
+                       CResult_InvoiceNoneZPtr { result }
                } else {
-                       let err = unsafe { o.contents.err };
-                       unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_DirectionalChannelInfoDecodeErrorZPtr { err }
+                       let _ = unsafe { Box::from_raw(o.contents.err) };
+                       o.contents.err = std::ptr::null_mut();
+                       CResult_InvoiceNoneZPtr { err: std::ptr::null_mut() }
                };
                Self {
                        contents,
@@ -4893,90 +4715,86 @@ impl From<crate::c_types::CResultTempl<crate::lightning::routing::network_graph:
                }
        }
 }
-impl Clone for CResult_DirectionalChannelInfoDecodeErrorZ {
+impl Clone for CResult_InvoiceNoneZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_DirectionalChannelInfoDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::routing::network_graph::DirectionalChannelInfo>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_InvoiceNoneZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning_invoice::Invoice>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_DirectionalChannelInfoDecodeErrorZPtr {
-                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
+                       Self { result_ok: false, contents: CResult_InvoiceNoneZPtr {
+                               err: std::ptr::null_mut()
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_DirectionalChannelInfoDecodeErrorZ which has the same data as `orig`
+/// Creates a new CResult_InvoiceNoneZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_DirectionalChannelInfoDecodeErrorZ_clone(orig: &CResult_DirectionalChannelInfoDecodeErrorZ) -> CResult_DirectionalChannelInfoDecodeErrorZ { orig.clone() }
+pub extern "C" fn CResult_InvoiceNoneZ_clone(orig: &CResult_InvoiceNoneZ) -> CResult_InvoiceNoneZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_ChannelInfoDecodeErrorZ
-pub union CResult_ChannelInfoDecodeErrorZPtr {
+/// The contents of CResult_SignedRawInvoiceNoneZ
+pub union CResult_SignedRawInvoiceNoneZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::routing::network_graph::ChannelInfo,
-       /// A pointer to the contents in the error state.
-       /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::lightning::ln::msgs::DecodeError,
+       pub result: *mut crate::lightning_invoice::SignedRawInvoice,
+       /// Note that this value is always NULL, as there are no contents in the Err variant
+       pub err: *mut std::ffi::c_void,
 }
 #[repr(C)]
-/// 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.
+/// A CResult_SignedRawInvoiceNoneZ represents the result of a fallible operation,
+/// containing a crate::lightning_invoice::SignedRawInvoice on success and a () on failure.
 /// `result_ok` indicates the overall state, and the contents are provided via `contents`.
-pub struct CResult_ChannelInfoDecodeErrorZ {
-       /// The contents of this CResult_ChannelInfoDecodeErrorZ, accessible via either
+pub struct CResult_SignedRawInvoiceNoneZ {
+       /// The contents of this CResult_SignedRawInvoiceNoneZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_ChannelInfoDecodeErrorZPtr,
-       /// Whether this CResult_ChannelInfoDecodeErrorZ represents a success state.
+       pub contents: CResult_SignedRawInvoiceNoneZPtr,
+       /// Whether this CResult_SignedRawInvoiceNoneZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_ChannelInfoDecodeErrorZ in the success state.
-pub extern "C" fn CResult_ChannelInfoDecodeErrorZ_ok(o: crate::lightning::routing::network_graph::ChannelInfo) -> CResult_ChannelInfoDecodeErrorZ {
-       CResult_ChannelInfoDecodeErrorZ {
-               contents: CResult_ChannelInfoDecodeErrorZPtr {
+/// Creates a new CResult_SignedRawInvoiceNoneZ in the success state.
+pub extern "C" fn CResult_SignedRawInvoiceNoneZ_ok(o: crate::lightning_invoice::SignedRawInvoice) -> CResult_SignedRawInvoiceNoneZ {
+       CResult_SignedRawInvoiceNoneZ {
+               contents: CResult_SignedRawInvoiceNoneZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_ChannelInfoDecodeErrorZ in the error state.
-pub extern "C" fn CResult_ChannelInfoDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_ChannelInfoDecodeErrorZ {
-       CResult_ChannelInfoDecodeErrorZ {
-               contents: CResult_ChannelInfoDecodeErrorZPtr {
-                       err: Box::into_raw(Box::new(e)),
+/// Creates a new CResult_SignedRawInvoiceNoneZ in the error state.
+pub extern "C" fn CResult_SignedRawInvoiceNoneZ_err() -> CResult_SignedRawInvoiceNoneZ {
+       CResult_SignedRawInvoiceNoneZ {
+               contents: CResult_SignedRawInvoiceNoneZPtr {
+                       err: std::ptr::null_mut(),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_ChannelInfoDecodeErrorZ.
-pub extern "C" fn CResult_ChannelInfoDecodeErrorZ_free(_res: CResult_ChannelInfoDecodeErrorZ) { }
-impl Drop for CResult_ChannelInfoDecodeErrorZ {
+/// Frees any resources used by the CResult_SignedRawInvoiceNoneZ.
+pub extern "C" fn CResult_SignedRawInvoiceNoneZ_free(_res: CResult_SignedRawInvoiceNoneZ) { }
+impl Drop for CResult_SignedRawInvoiceNoneZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
                                let _ = unsafe { Box::from_raw(self.contents.result) };
                        }
                } else {
-                       if unsafe { !(self.contents.err as *mut ()).is_null() } {
-                               let _ = unsafe { Box::from_raw(self.contents.err) };
-                       }
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::routing::network_graph::ChannelInfo, crate::lightning::ln::msgs::DecodeError>> for CResult_ChannelInfoDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::routing::network_graph::ChannelInfo, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning_invoice::SignedRawInvoice, ()>> for CResult_SignedRawInvoiceNoneZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning_invoice::SignedRawInvoice, ()>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_ChannelInfoDecodeErrorZPtr { result }
+                       CResult_SignedRawInvoiceNoneZPtr { result }
                } else {
-                       let err = unsafe { o.contents.err };
-                       unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_ChannelInfoDecodeErrorZPtr { err }
+                       let _ = unsafe { Box::from_raw(o.contents.err) };
+                       o.contents.err = std::ptr::null_mut();
+                       CResult_SignedRawInvoiceNoneZPtr { err: std::ptr::null_mut() }
                };
                Self {
                        contents,
@@ -4984,68 +4802,114 @@ impl From<crate::c_types::CResultTempl<crate::lightning::routing::network_graph:
                }
        }
 }
-impl Clone for CResult_ChannelInfoDecodeErrorZ {
+impl Clone for CResult_SignedRawInvoiceNoneZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_ChannelInfoDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::routing::network_graph::ChannelInfo>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_SignedRawInvoiceNoneZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning_invoice::SignedRawInvoice>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_ChannelInfoDecodeErrorZPtr {
-                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
+                       Self { result_ok: false, contents: CResult_SignedRawInvoiceNoneZPtr {
+                               err: std::ptr::null_mut()
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_ChannelInfoDecodeErrorZ which has the same data as `orig`
+/// Creates a new CResult_SignedRawInvoiceNoneZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_ChannelInfoDecodeErrorZ_clone(orig: &CResult_ChannelInfoDecodeErrorZ) -> CResult_ChannelInfoDecodeErrorZ { orig.clone() }
+pub extern "C" fn CResult_SignedRawInvoiceNoneZ_clone(orig: &CResult_SignedRawInvoiceNoneZ) -> CResult_SignedRawInvoiceNoneZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_RoutingFeesDecodeErrorZ
-pub union CResult_RoutingFeesDecodeErrorZPtr {
+/// A tuple of 3 elements. See the individual fields for the types contained.
+pub struct C3Tuple_RawInvoice_u832InvoiceSignatureZ {
+       /// The element at position 0
+       pub a: crate::lightning_invoice::RawInvoice,
+       /// The element at position 1
+       pub b: crate::c_types::ThirtyTwoBytes,
+       /// The element at position 2
+       pub c: crate::lightning_invoice::InvoiceSignature,
+}
+impl From<(crate::lightning_invoice::RawInvoice, crate::c_types::ThirtyTwoBytes, crate::lightning_invoice::InvoiceSignature)> for C3Tuple_RawInvoice_u832InvoiceSignatureZ {
+       fn from (tup: (crate::lightning_invoice::RawInvoice, crate::c_types::ThirtyTwoBytes, crate::lightning_invoice::InvoiceSignature)) -> Self {
+               Self {
+                       a: tup.0,
+                       b: tup.1,
+                       c: tup.2,
+               }
+       }
+}
+impl C3Tuple_RawInvoice_u832InvoiceSignatureZ {
+       #[allow(unused)] pub(crate) fn to_rust(mut self) -> (crate::lightning_invoice::RawInvoice, crate::c_types::ThirtyTwoBytes, crate::lightning_invoice::InvoiceSignature) {
+               (self.a, self.b, self.c)
+       }
+}
+impl Clone for C3Tuple_RawInvoice_u832InvoiceSignatureZ {
+       fn clone(&self) -> Self {
+               Self {
+                       a: self.a.clone(),
+                       b: self.b.clone(),
+                       c: self.c.clone(),
+               }
+       }
+}
+#[no_mangle]
+/// Creates a new tuple which has the same data as `orig`
+/// but with all dynamically-allocated buffers duplicated in new buffers.
+pub extern "C" fn C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(orig: &C3Tuple_RawInvoice_u832InvoiceSignatureZ) -> C3Tuple_RawInvoice_u832InvoiceSignatureZ { orig.clone() }
+/// Creates a new C3Tuple_RawInvoice_u832InvoiceSignatureZ from the contained elements.
+#[no_mangle]
+pub extern "C" fn C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a: crate::lightning_invoice::RawInvoice, b: crate::c_types::ThirtyTwoBytes, c: crate::lightning_invoice::InvoiceSignature) -> C3Tuple_RawInvoice_u832InvoiceSignatureZ {
+       C3Tuple_RawInvoice_u832InvoiceSignatureZ { a, b, c, }
+}
+
+#[no_mangle]
+/// Frees any resources used by the C3Tuple_RawInvoice_u832InvoiceSignatureZ.
+pub extern "C" fn C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(_res: C3Tuple_RawInvoice_u832InvoiceSignatureZ) { }
+#[repr(C)]
+/// The contents of CResult_PayeePubKeyErrorZ
+pub union CResult_PayeePubKeyErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::routing::network_graph::RoutingFees,
+       pub result: *mut crate::lightning_invoice::PayeePubKey,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::lightning::ln::msgs::DecodeError,
+       pub err: *mut crate::c_types::Secp256k1Error,
 }
 #[repr(C)]
-/// 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.
+/// 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`.
-pub struct CResult_RoutingFeesDecodeErrorZ {
-       /// The contents of this CResult_RoutingFeesDecodeErrorZ, accessible via either
+pub struct CResult_PayeePubKeyErrorZ {
+       /// The contents of this CResult_PayeePubKeyErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_RoutingFeesDecodeErrorZPtr,
-       /// Whether this CResult_RoutingFeesDecodeErrorZ represents a success state.
+       pub contents: CResult_PayeePubKeyErrorZPtr,
+       /// Whether this CResult_PayeePubKeyErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_RoutingFeesDecodeErrorZ in the success state.
-pub extern "C" fn CResult_RoutingFeesDecodeErrorZ_ok(o: crate::lightning::routing::network_graph::RoutingFees) -> CResult_RoutingFeesDecodeErrorZ {
-       CResult_RoutingFeesDecodeErrorZ {
-               contents: CResult_RoutingFeesDecodeErrorZPtr {
+/// Creates a new CResult_PayeePubKeyErrorZ in the success state.
+pub extern "C" fn CResult_PayeePubKeyErrorZ_ok(o: crate::lightning_invoice::PayeePubKey) -> CResult_PayeePubKeyErrorZ {
+       CResult_PayeePubKeyErrorZ {
+               contents: CResult_PayeePubKeyErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_RoutingFeesDecodeErrorZ in the error state.
-pub extern "C" fn CResult_RoutingFeesDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_RoutingFeesDecodeErrorZ {
-       CResult_RoutingFeesDecodeErrorZ {
-               contents: CResult_RoutingFeesDecodeErrorZPtr {
+/// Creates a new CResult_PayeePubKeyErrorZ in the error state.
+pub extern "C" fn CResult_PayeePubKeyErrorZ_err(e: crate::c_types::Secp256k1Error) -> CResult_PayeePubKeyErrorZ {
+       CResult_PayeePubKeyErrorZ {
+               contents: CResult_PayeePubKeyErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_RoutingFeesDecodeErrorZ.
-pub extern "C" fn CResult_RoutingFeesDecodeErrorZ_free(_res: CResult_RoutingFeesDecodeErrorZ) { }
-impl Drop for CResult_RoutingFeesDecodeErrorZ {
+/// Frees any resources used by the CResult_PayeePubKeyErrorZ.
+pub extern "C" fn CResult_PayeePubKeyErrorZ_free(_res: CResult_PayeePubKeyErrorZ) { }
+impl Drop for CResult_PayeePubKeyErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -5058,16 +4922,16 @@ impl Drop for CResult_RoutingFeesDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::routing::network_graph::RoutingFees, crate::lightning::ln::msgs::DecodeError>> for CResult_RoutingFeesDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::routing::network_graph::RoutingFees, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning_invoice::PayeePubKey, crate::c_types::Secp256k1Error>> for CResult_PayeePubKeyErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning_invoice::PayeePubKey, crate::c_types::Secp256k1Error>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_RoutingFeesDecodeErrorZPtr { result }
+                       CResult_PayeePubKeyErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_RoutingFeesDecodeErrorZPtr { err }
+                       CResult_PayeePubKeyErrorZPtr { err }
                };
                Self {
                        contents,
@@ -5075,47 +4939,47 @@ impl From<crate::c_types::CResultTempl<crate::lightning::routing::network_graph:
                }
        }
 }
-impl Clone for CResult_RoutingFeesDecodeErrorZ {
+impl Clone for CResult_PayeePubKeyErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_RoutingFeesDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::routing::network_graph::RoutingFees>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_PayeePubKeyErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning_invoice::PayeePubKey>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_RoutingFeesDecodeErrorZPtr {
-                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
+                       Self { result_ok: false, contents: CResult_PayeePubKeyErrorZPtr {
+                               err: Box::into_raw(Box::new(<crate::c_types::Secp256k1Error>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_RoutingFeesDecodeErrorZ which has the same data as `orig`
+/// Creates a new CResult_PayeePubKeyErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_RoutingFeesDecodeErrorZ_clone(orig: &CResult_RoutingFeesDecodeErrorZ) -> CResult_RoutingFeesDecodeErrorZ { orig.clone() }
+pub extern "C" fn CResult_PayeePubKeyErrorZ_clone(orig: &CResult_PayeePubKeyErrorZ) -> CResult_PayeePubKeyErrorZ { orig.clone() }
 #[repr(C)]
-/// A dynamically-allocated array of crate::lightning::ln::msgs::NetAddresss of arbitrary size.
+/// A dynamically-allocated array of crate::lightning_invoice::RouteHints of arbitrary size.
 /// This corresponds to std::vector in C++
-pub struct CVec_NetAddressZ {
+pub struct CVec_RouteHintZ {
        /// The elements in the array.
        /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
-       pub data: *mut crate::lightning::ln::msgs::NetAddress,
+       pub data: *mut crate::lightning_invoice::RouteHint,
        /// The number of elements pointed to by `data`.
        pub datalen: usize
 }
-impl CVec_NetAddressZ {
-       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::lightning::ln::msgs::NetAddress> {
+impl CVec_RouteHintZ {
+       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::lightning_invoice::RouteHint> {
                if self.datalen == 0 { return Vec::new(); }
                let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
                self.data = std::ptr::null_mut();
                self.datalen = 0;
                ret
        }
-       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::lightning::ln::msgs::NetAddress] {
+       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::lightning_invoice::RouteHint] {
                unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
        }
 }
-impl From<Vec<crate::lightning::ln::msgs::NetAddress>> for CVec_NetAddressZ {
-       fn from(v: Vec<crate::lightning::ln::msgs::NetAddress>) -> Self {
+impl From<Vec<crate::lightning_invoice::RouteHint>> for CVec_RouteHintZ {
+       fn from(v: Vec<crate::lightning_invoice::RouteHint>) -> Self {
                let datalen = v.len();
                let data = Box::into_raw(v.into_boxed_slice());
                Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
@@ -5123,14 +4987,14 @@ impl From<Vec<crate::lightning::ln::msgs::NetAddress>> for CVec_NetAddressZ {
 }
 #[no_mangle]
 /// Frees the buffer pointed to by `data` if `datalen` is non-0.
-pub extern "C" fn CVec_NetAddressZ_free(_res: CVec_NetAddressZ) { }
-impl Drop for CVec_NetAddressZ {
+pub extern "C" fn CVec_RouteHintZ_free(_res: CVec_RouteHintZ) { }
+impl Drop for CVec_RouteHintZ {
        fn drop(&mut self) {
                if self.datalen == 0 { return; }
                unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
        }
 }
-impl Clone for CVec_NetAddressZ {
+impl Clone for CVec_RouteHintZ {
        fn clone(&self) -> Self {
                let mut res = Vec::new();
                if self.datalen == 0 { return Self::from(res); }
@@ -5139,50 +5003,50 @@ impl Clone for CVec_NetAddressZ {
        }
 }
 #[repr(C)]
-/// The contents of CResult_NodeAnnouncementInfoDecodeErrorZ
-pub union CResult_NodeAnnouncementInfoDecodeErrorZPtr {
+/// The contents of CResult_PositiveTimestampCreationErrorZ
+pub union CResult_PositiveTimestampCreationErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::routing::network_graph::NodeAnnouncementInfo,
+       pub result: *mut crate::lightning_invoice::PositiveTimestamp,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::lightning::ln::msgs::DecodeError,
+       pub err: *mut crate::lightning_invoice::CreationError,
 }
 #[repr(C)]
-/// 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.
+/// 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`.
-pub struct CResult_NodeAnnouncementInfoDecodeErrorZ {
-       /// The contents of this CResult_NodeAnnouncementInfoDecodeErrorZ, accessible via either
+pub struct CResult_PositiveTimestampCreationErrorZ {
+       /// The contents of this CResult_PositiveTimestampCreationErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_NodeAnnouncementInfoDecodeErrorZPtr,
-       /// Whether this CResult_NodeAnnouncementInfoDecodeErrorZ represents a success state.
+       pub contents: CResult_PositiveTimestampCreationErrorZPtr,
+       /// Whether this CResult_PositiveTimestampCreationErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_NodeAnnouncementInfoDecodeErrorZ in the success state.
-pub extern "C" fn CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o: crate::lightning::routing::network_graph::NodeAnnouncementInfo) -> CResult_NodeAnnouncementInfoDecodeErrorZ {
-       CResult_NodeAnnouncementInfoDecodeErrorZ {
-               contents: CResult_NodeAnnouncementInfoDecodeErrorZPtr {
+/// Creates a new CResult_PositiveTimestampCreationErrorZ in the success state.
+pub extern "C" fn CResult_PositiveTimestampCreationErrorZ_ok(o: crate::lightning_invoice::PositiveTimestamp) -> CResult_PositiveTimestampCreationErrorZ {
+       CResult_PositiveTimestampCreationErrorZ {
+               contents: CResult_PositiveTimestampCreationErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_NodeAnnouncementInfoDecodeErrorZ in the error state.
-pub extern "C" fn CResult_NodeAnnouncementInfoDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_NodeAnnouncementInfoDecodeErrorZ {
-       CResult_NodeAnnouncementInfoDecodeErrorZ {
-               contents: CResult_NodeAnnouncementInfoDecodeErrorZPtr {
+/// Creates a new CResult_PositiveTimestampCreationErrorZ in the error state.
+pub extern "C" fn CResult_PositiveTimestampCreationErrorZ_err(e: crate::lightning_invoice::CreationError) -> CResult_PositiveTimestampCreationErrorZ {
+       CResult_PositiveTimestampCreationErrorZ {
+               contents: CResult_PositiveTimestampCreationErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_NodeAnnouncementInfoDecodeErrorZ.
-pub extern "C" fn CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res: CResult_NodeAnnouncementInfoDecodeErrorZ) { }
-impl Drop for CResult_NodeAnnouncementInfoDecodeErrorZ {
+/// Frees any resources used by the CResult_PositiveTimestampCreationErrorZ.
+pub extern "C" fn CResult_PositiveTimestampCreationErrorZ_free(_res: CResult_PositiveTimestampCreationErrorZ) { }
+impl Drop for CResult_PositiveTimestampCreationErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -5195,16 +5059,16 @@ impl Drop for CResult_NodeAnnouncementInfoDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::routing::network_graph::NodeAnnouncementInfo, crate::lightning::ln::msgs::DecodeError>> for CResult_NodeAnnouncementInfoDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::routing::network_graph::NodeAnnouncementInfo, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning_invoice::PositiveTimestamp, crate::lightning_invoice::CreationError>> for CResult_PositiveTimestampCreationErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning_invoice::PositiveTimestamp, crate::lightning_invoice::CreationError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_NodeAnnouncementInfoDecodeErrorZPtr { result }
+                       CResult_PositiveTimestampCreationErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_NodeAnnouncementInfoDecodeErrorZPtr { err }
+                       CResult_PositiveTimestampCreationErrorZPtr { err }
                };
                Self {
                        contents,
@@ -5212,114 +5076,155 @@ impl From<crate::c_types::CResultTempl<crate::lightning::routing::network_graph:
                }
        }
 }
-impl Clone for CResult_NodeAnnouncementInfoDecodeErrorZ {
+impl Clone for CResult_PositiveTimestampCreationErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_NodeAnnouncementInfoDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::routing::network_graph::NodeAnnouncementInfo>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_PositiveTimestampCreationErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning_invoice::PositiveTimestamp>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_NodeAnnouncementInfoDecodeErrorZPtr {
-                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
+                       Self { result_ok: false, contents: CResult_PositiveTimestampCreationErrorZPtr {
+                               err: Box::into_raw(Box::new(<crate::lightning_invoice::CreationError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_NodeAnnouncementInfoDecodeErrorZ which has the same data as `orig`
+/// Creates a new CResult_PositiveTimestampCreationErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig: &CResult_NodeAnnouncementInfoDecodeErrorZ) -> CResult_NodeAnnouncementInfoDecodeErrorZ { orig.clone() }
+pub extern "C" fn CResult_PositiveTimestampCreationErrorZ_clone(orig: &CResult_PositiveTimestampCreationErrorZ) -> CResult_PositiveTimestampCreationErrorZ { orig.clone() }
 #[repr(C)]
-/// A dynamically-allocated array of u64s of arbitrary size.
-/// This corresponds to std::vector in C++
-pub struct CVec_u64Z {
-       /// The elements in the array.
-       /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
-       pub data: *mut u64,
-       /// The number of elements pointed to by `data`.
-       pub datalen: usize
+/// The contents of CResult_NoneSemanticErrorZ
+pub union CResult_NoneSemanticErrorZPtr {
+       /// Note that this value is always NULL, as there are no contents in the OK variant
+       pub result: *mut std::ffi::c_void,
+       /// A pointer to the contents in the error state.
+       /// Reading from this pointer when `result_ok` is set is undefined.
+       pub err: *mut crate::lightning_invoice::SemanticError,
 }
-impl CVec_u64Z {
-       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<u64> {
-               if self.datalen == 0 { return Vec::new(); }
-               let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
-               self.data = std::ptr::null_mut();
-               self.datalen = 0;
-               ret
-       }
-       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[u64] {
-               unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
+#[repr(C)]
+/// 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`.
+pub struct CResult_NoneSemanticErrorZ {
+       /// The contents of this CResult_NoneSemanticErrorZ, accessible via either
+       /// `err` or `result` depending on the state of `result_ok`.
+       pub contents: CResult_NoneSemanticErrorZPtr,
+       /// Whether this CResult_NoneSemanticErrorZ represents a success state.
+       pub result_ok: bool,
+}
+#[no_mangle]
+/// Creates a new CResult_NoneSemanticErrorZ in the success state.
+pub extern "C" fn CResult_NoneSemanticErrorZ_ok() -> CResult_NoneSemanticErrorZ {
+       CResult_NoneSemanticErrorZ {
+               contents: CResult_NoneSemanticErrorZPtr {
+                       result: std::ptr::null_mut(),
+               },
+               result_ok: true,
        }
 }
-impl From<Vec<u64>> for CVec_u64Z {
-       fn from(v: Vec<u64>) -> Self {
-               let datalen = v.len();
-               let data = Box::into_raw(v.into_boxed_slice());
-               Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
+#[no_mangle]
+/// Creates a new CResult_NoneSemanticErrorZ in the error state.
+pub extern "C" fn CResult_NoneSemanticErrorZ_err(e: crate::lightning_invoice::SemanticError) -> CResult_NoneSemanticErrorZ {
+       CResult_NoneSemanticErrorZ {
+               contents: CResult_NoneSemanticErrorZPtr {
+                       err: Box::into_raw(Box::new(e)),
+               },
+               result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees the buffer pointed to by `data` if `datalen` is non-0.
-pub extern "C" fn CVec_u64Z_free(_res: CVec_u64Z) { }
-impl Drop for CVec_u64Z {
+/// Frees any resources used by the CResult_NoneSemanticErrorZ.
+pub extern "C" fn CResult_NoneSemanticErrorZ_free(_res: CResult_NoneSemanticErrorZ) { }
+impl Drop for CResult_NoneSemanticErrorZ {
        fn drop(&mut self) {
-               if self.datalen == 0 { return; }
-               unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
+               if self.result_ok {
+               } else {
+                       if unsafe { !(self.contents.err as *mut ()).is_null() } {
+                               let _ = unsafe { Box::from_raw(self.contents.err) };
+                       }
+               }
        }
 }
-impl Clone for CVec_u64Z {
+impl From<crate::c_types::CResultTempl<(), crate::lightning_invoice::SemanticError>> for CResult_NoneSemanticErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<(), crate::lightning_invoice::SemanticError>) -> Self {
+               let contents = if o.result_ok {
+                       let _ = unsafe { Box::from_raw(o.contents.result) };
+                       o.contents.result = std::ptr::null_mut();
+                       CResult_NoneSemanticErrorZPtr { result: std::ptr::null_mut() }
+               } else {
+                       let err = unsafe { o.contents.err };
+                       unsafe { o.contents.err = std::ptr::null_mut(); }
+                       CResult_NoneSemanticErrorZPtr { err }
+               };
+               Self {
+                       contents,
+                       result_ok: o.result_ok,
+               }
+       }
+}
+impl Clone for CResult_NoneSemanticErrorZ {
        fn clone(&self) -> Self {
-               let mut res = Vec::new();
-               if self.datalen == 0 { return Self::from(res); }
-               res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
-               Self::from(res)
+               if self.result_ok {
+                       Self { result_ok: true, contents: CResult_NoneSemanticErrorZPtr {
+                               result: std::ptr::null_mut()
+                       } }
+               } else {
+                       Self { result_ok: false, contents: CResult_NoneSemanticErrorZPtr {
+                               err: Box::into_raw(Box::new(<crate::lightning_invoice::SemanticError>::clone(unsafe { &*self.contents.err })))
+                       } }
+               }
        }
 }
+#[no_mangle]
+/// Creates a new CResult_NoneSemanticErrorZ which has the same data as `orig`
+/// but with all dynamically-allocated buffers duplicated in new buffers.
+pub extern "C" fn CResult_NoneSemanticErrorZ_clone(orig: &CResult_NoneSemanticErrorZ) -> CResult_NoneSemanticErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_NodeInfoDecodeErrorZ
-pub union CResult_NodeInfoDecodeErrorZPtr {
+/// The contents of CResult_InvoiceSemanticErrorZ
+pub union CResult_InvoiceSemanticErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::routing::network_graph::NodeInfo,
+       pub result: *mut crate::lightning_invoice::Invoice,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::lightning::ln::msgs::DecodeError,
+       pub err: *mut crate::lightning_invoice::SemanticError,
 }
 #[repr(C)]
-/// 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_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`.
-pub struct CResult_NodeInfoDecodeErrorZ {
-       /// The contents of this CResult_NodeInfoDecodeErrorZ, accessible via either
+pub struct CResult_InvoiceSemanticErrorZ {
+       /// The contents of this CResult_InvoiceSemanticErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_NodeInfoDecodeErrorZPtr,
-       /// Whether this CResult_NodeInfoDecodeErrorZ represents a success state.
+       pub contents: CResult_InvoiceSemanticErrorZPtr,
+       /// Whether this CResult_InvoiceSemanticErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_NodeInfoDecodeErrorZ in the success state.
-pub extern "C" fn CResult_NodeInfoDecodeErrorZ_ok(o: crate::lightning::routing::network_graph::NodeInfo) -> CResult_NodeInfoDecodeErrorZ {
-       CResult_NodeInfoDecodeErrorZ {
-               contents: CResult_NodeInfoDecodeErrorZPtr {
+/// Creates a new CResult_InvoiceSemanticErrorZ in the success state.
+pub extern "C" fn CResult_InvoiceSemanticErrorZ_ok(o: crate::lightning_invoice::Invoice) -> CResult_InvoiceSemanticErrorZ {
+       CResult_InvoiceSemanticErrorZ {
+               contents: CResult_InvoiceSemanticErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_NodeInfoDecodeErrorZ in the error state.
-pub extern "C" fn CResult_NodeInfoDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_NodeInfoDecodeErrorZ {
-       CResult_NodeInfoDecodeErrorZ {
-               contents: CResult_NodeInfoDecodeErrorZPtr {
+/// Creates a new CResult_InvoiceSemanticErrorZ in the error state.
+pub extern "C" fn CResult_InvoiceSemanticErrorZ_err(e: crate::lightning_invoice::SemanticError) -> CResult_InvoiceSemanticErrorZ {
+       CResult_InvoiceSemanticErrorZ {
+               contents: CResult_InvoiceSemanticErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_NodeInfoDecodeErrorZ.
-pub extern "C" fn CResult_NodeInfoDecodeErrorZ_free(_res: CResult_NodeInfoDecodeErrorZ) { }
-impl Drop for CResult_NodeInfoDecodeErrorZ {
+/// Frees any resources used by the CResult_InvoiceSemanticErrorZ.
+pub extern "C" fn CResult_InvoiceSemanticErrorZ_free(_res: CResult_InvoiceSemanticErrorZ) { }
+impl Drop for CResult_InvoiceSemanticErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -5332,16 +5237,16 @@ impl Drop for CResult_NodeInfoDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::routing::network_graph::NodeInfo, crate::lightning::ln::msgs::DecodeError>> for CResult_NodeInfoDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::routing::network_graph::NodeInfo, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning_invoice::Invoice, crate::lightning_invoice::SemanticError>> for CResult_InvoiceSemanticErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning_invoice::Invoice, crate::lightning_invoice::SemanticError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_NodeInfoDecodeErrorZPtr { result }
+                       CResult_InvoiceSemanticErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_NodeInfoDecodeErrorZPtr { err }
+                       CResult_InvoiceSemanticErrorZPtr { err }
                };
                Self {
                        contents,
@@ -5349,68 +5254,68 @@ impl From<crate::c_types::CResultTempl<crate::lightning::routing::network_graph:
                }
        }
 }
-impl Clone for CResult_NodeInfoDecodeErrorZ {
+impl Clone for CResult_InvoiceSemanticErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_NodeInfoDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::routing::network_graph::NodeInfo>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_InvoiceSemanticErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning_invoice::Invoice>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_NodeInfoDecodeErrorZPtr {
-                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
+                       Self { result_ok: false, contents: CResult_InvoiceSemanticErrorZPtr {
+                               err: Box::into_raw(Box::new(<crate::lightning_invoice::SemanticError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_NodeInfoDecodeErrorZ which has the same data as `orig`
+/// Creates a new CResult_InvoiceSemanticErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_NodeInfoDecodeErrorZ_clone(orig: &CResult_NodeInfoDecodeErrorZ) -> CResult_NodeInfoDecodeErrorZ { orig.clone() }
+pub extern "C" fn CResult_InvoiceSemanticErrorZ_clone(orig: &CResult_InvoiceSemanticErrorZ) -> CResult_InvoiceSemanticErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_NetworkGraphDecodeErrorZ
-pub union CResult_NetworkGraphDecodeErrorZPtr {
+/// The contents of CResult_DescriptionCreationErrorZ
+pub union CResult_DescriptionCreationErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::routing::network_graph::NetworkGraph,
+       pub result: *mut crate::lightning_invoice::Description,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::lightning::ln::msgs::DecodeError,
+       pub err: *mut crate::lightning_invoice::CreationError,
 }
 #[repr(C)]
-/// 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_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`.
-pub struct CResult_NetworkGraphDecodeErrorZ {
-       /// The contents of this CResult_NetworkGraphDecodeErrorZ, accessible via either
+pub struct CResult_DescriptionCreationErrorZ {
+       /// The contents of this CResult_DescriptionCreationErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_NetworkGraphDecodeErrorZPtr,
-       /// Whether this CResult_NetworkGraphDecodeErrorZ represents a success state.
+       pub contents: CResult_DescriptionCreationErrorZPtr,
+       /// Whether this CResult_DescriptionCreationErrorZ represents a success state.
        pub result_ok: bool,
 }
-#[no_mangle]
-/// Creates a new CResult_NetworkGraphDecodeErrorZ in the success state.
-pub extern "C" fn CResult_NetworkGraphDecodeErrorZ_ok(o: crate::lightning::routing::network_graph::NetworkGraph) -> CResult_NetworkGraphDecodeErrorZ {
-       CResult_NetworkGraphDecodeErrorZ {
-               contents: CResult_NetworkGraphDecodeErrorZPtr {
+#[no_mangle]
+/// Creates a new CResult_DescriptionCreationErrorZ in the success state.
+pub extern "C" fn CResult_DescriptionCreationErrorZ_ok(o: crate::lightning_invoice::Description) -> CResult_DescriptionCreationErrorZ {
+       CResult_DescriptionCreationErrorZ {
+               contents: CResult_DescriptionCreationErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_NetworkGraphDecodeErrorZ in the error state.
-pub extern "C" fn CResult_NetworkGraphDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_NetworkGraphDecodeErrorZ {
-       CResult_NetworkGraphDecodeErrorZ {
-               contents: CResult_NetworkGraphDecodeErrorZPtr {
+/// Creates a new CResult_DescriptionCreationErrorZ in the error state.
+pub extern "C" fn CResult_DescriptionCreationErrorZ_err(e: crate::lightning_invoice::CreationError) -> CResult_DescriptionCreationErrorZ {
+       CResult_DescriptionCreationErrorZ {
+               contents: CResult_DescriptionCreationErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_NetworkGraphDecodeErrorZ.
-pub extern "C" fn CResult_NetworkGraphDecodeErrorZ_free(_res: CResult_NetworkGraphDecodeErrorZ) { }
-impl Drop for CResult_NetworkGraphDecodeErrorZ {
+/// Frees any resources used by the CResult_DescriptionCreationErrorZ.
+pub extern "C" fn CResult_DescriptionCreationErrorZ_free(_res: CResult_DescriptionCreationErrorZ) { }
+impl Drop for CResult_DescriptionCreationErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -5423,16 +5328,16 @@ impl Drop for CResult_NetworkGraphDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::routing::network_graph::NetworkGraph, crate::lightning::ln::msgs::DecodeError>> for CResult_NetworkGraphDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::routing::network_graph::NetworkGraph, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning_invoice::Description, crate::lightning_invoice::CreationError>> for CResult_DescriptionCreationErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning_invoice::Description, crate::lightning_invoice::CreationError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_NetworkGraphDecodeErrorZPtr { result }
+                       CResult_DescriptionCreationErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_NetworkGraphDecodeErrorZPtr { err }
+                       CResult_DescriptionCreationErrorZPtr { err }
                };
                Self {
                        contents,
@@ -5440,68 +5345,68 @@ impl From<crate::c_types::CResultTempl<crate::lightning::routing::network_graph:
                }
        }
 }
-impl Clone for CResult_NetworkGraphDecodeErrorZ {
+impl Clone for CResult_DescriptionCreationErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_NetworkGraphDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::routing::network_graph::NetworkGraph>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_DescriptionCreationErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning_invoice::Description>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_NetworkGraphDecodeErrorZPtr {
-                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
+                       Self { result_ok: false, contents: CResult_DescriptionCreationErrorZPtr {
+                               err: Box::into_raw(Box::new(<crate::lightning_invoice::CreationError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_NetworkGraphDecodeErrorZ which has the same data as `orig`
+/// Creates a new CResult_DescriptionCreationErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_NetworkGraphDecodeErrorZ_clone(orig: &CResult_NetworkGraphDecodeErrorZ) -> CResult_NetworkGraphDecodeErrorZ { orig.clone() }
+pub extern "C" fn CResult_DescriptionCreationErrorZ_clone(orig: &CResult_DescriptionCreationErrorZ) -> CResult_DescriptionCreationErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_InitFeaturesDecodeErrorZ
-pub union CResult_InitFeaturesDecodeErrorZPtr {
+/// The contents of CResult_ExpiryTimeCreationErrorZ
+pub union CResult_ExpiryTimeCreationErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::ln::features::InitFeatures,
+       pub result: *mut crate::lightning_invoice::ExpiryTime,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::lightning::ln::msgs::DecodeError,
+       pub err: *mut crate::lightning_invoice::CreationError,
 }
 #[repr(C)]
-/// 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_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`.
-pub struct CResult_InitFeaturesDecodeErrorZ {
-       /// The contents of this CResult_InitFeaturesDecodeErrorZ, accessible via either
+pub struct CResult_ExpiryTimeCreationErrorZ {
+       /// The contents of this CResult_ExpiryTimeCreationErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_InitFeaturesDecodeErrorZPtr,
-       /// Whether this CResult_InitFeaturesDecodeErrorZ represents a success state.
+       pub contents: CResult_ExpiryTimeCreationErrorZPtr,
+       /// Whether this CResult_ExpiryTimeCreationErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_InitFeaturesDecodeErrorZ in the success state.
-pub extern "C" fn CResult_InitFeaturesDecodeErrorZ_ok(o: crate::lightning::ln::features::InitFeatures) -> CResult_InitFeaturesDecodeErrorZ {
-       CResult_InitFeaturesDecodeErrorZ {
-               contents: CResult_InitFeaturesDecodeErrorZPtr {
+/// Creates a new CResult_ExpiryTimeCreationErrorZ in the success state.
+pub extern "C" fn CResult_ExpiryTimeCreationErrorZ_ok(o: crate::lightning_invoice::ExpiryTime) -> CResult_ExpiryTimeCreationErrorZ {
+       CResult_ExpiryTimeCreationErrorZ {
+               contents: CResult_ExpiryTimeCreationErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_InitFeaturesDecodeErrorZ in the error state.
-pub extern "C" fn CResult_InitFeaturesDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_InitFeaturesDecodeErrorZ {
-       CResult_InitFeaturesDecodeErrorZ {
-               contents: CResult_InitFeaturesDecodeErrorZPtr {
+/// Creates a new CResult_ExpiryTimeCreationErrorZ in the error state.
+pub extern "C" fn CResult_ExpiryTimeCreationErrorZ_err(e: crate::lightning_invoice::CreationError) -> CResult_ExpiryTimeCreationErrorZ {
+       CResult_ExpiryTimeCreationErrorZ {
+               contents: CResult_ExpiryTimeCreationErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_InitFeaturesDecodeErrorZ.
-pub extern "C" fn CResult_InitFeaturesDecodeErrorZ_free(_res: CResult_InitFeaturesDecodeErrorZ) { }
-impl Drop for CResult_InitFeaturesDecodeErrorZ {
+/// Frees any resources used by the CResult_ExpiryTimeCreationErrorZ.
+pub extern "C" fn CResult_ExpiryTimeCreationErrorZ_free(_res: CResult_ExpiryTimeCreationErrorZ) { }
+impl Drop for CResult_ExpiryTimeCreationErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -5514,16 +5419,16 @@ impl Drop for CResult_InitFeaturesDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::ln::features::InitFeatures, crate::lightning::ln::msgs::DecodeError>> for CResult_InitFeaturesDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::features::InitFeatures, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning_invoice::ExpiryTime, crate::lightning_invoice::CreationError>> for CResult_ExpiryTimeCreationErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning_invoice::ExpiryTime, crate::lightning_invoice::CreationError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_InitFeaturesDecodeErrorZPtr { result }
+                       CResult_ExpiryTimeCreationErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_InitFeaturesDecodeErrorZPtr { err }
+                       CResult_ExpiryTimeCreationErrorZPtr { err }
                };
                Self {
                        contents,
@@ -5531,51 +5436,68 @@ impl From<crate::c_types::CResultTempl<crate::lightning::ln::features::InitFeatu
                }
        }
 }
+impl Clone for CResult_ExpiryTimeCreationErrorZ {
+       fn clone(&self) -> Self {
+               if self.result_ok {
+                       Self { result_ok: true, contents: CResult_ExpiryTimeCreationErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning_invoice::ExpiryTime>::clone(unsafe { &*self.contents.result })))
+                       } }
+               } else {
+                       Self { result_ok: false, contents: CResult_ExpiryTimeCreationErrorZPtr {
+                               err: Box::into_raw(Box::new(<crate::lightning_invoice::CreationError>::clone(unsafe { &*self.contents.err })))
+                       } }
+               }
+       }
+}
+#[no_mangle]
+/// Creates a new CResult_ExpiryTimeCreationErrorZ which has the same data as `orig`
+/// but with all dynamically-allocated buffers duplicated in new buffers.
+pub extern "C" fn CResult_ExpiryTimeCreationErrorZ_clone(orig: &CResult_ExpiryTimeCreationErrorZ) -> CResult_ExpiryTimeCreationErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_NodeFeaturesDecodeErrorZ
-pub union CResult_NodeFeaturesDecodeErrorZPtr {
+/// The contents of CResult_RouteHintCreationErrorZ
+pub union CResult_RouteHintCreationErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::ln::features::NodeFeatures,
+       pub result: *mut crate::lightning_invoice::RouteHint,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::lightning::ln::msgs::DecodeError,
+       pub err: *mut crate::lightning_invoice::CreationError,
 }
 #[repr(C)]
-/// 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_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`.
-pub struct CResult_NodeFeaturesDecodeErrorZ {
-       /// The contents of this CResult_NodeFeaturesDecodeErrorZ, accessible via either
+pub struct CResult_RouteHintCreationErrorZ {
+       /// The contents of this CResult_RouteHintCreationErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_NodeFeaturesDecodeErrorZPtr,
-       /// Whether this CResult_NodeFeaturesDecodeErrorZ represents a success state.
+       pub contents: CResult_RouteHintCreationErrorZPtr,
+       /// Whether this CResult_RouteHintCreationErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_NodeFeaturesDecodeErrorZ in the success state.
-pub extern "C" fn CResult_NodeFeaturesDecodeErrorZ_ok(o: crate::lightning::ln::features::NodeFeatures) -> CResult_NodeFeaturesDecodeErrorZ {
-       CResult_NodeFeaturesDecodeErrorZ {
-               contents: CResult_NodeFeaturesDecodeErrorZPtr {
+/// Creates a new CResult_RouteHintCreationErrorZ in the success state.
+pub extern "C" fn CResult_RouteHintCreationErrorZ_ok(o: crate::lightning_invoice::RouteHint) -> CResult_RouteHintCreationErrorZ {
+       CResult_RouteHintCreationErrorZ {
+               contents: CResult_RouteHintCreationErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_NodeFeaturesDecodeErrorZ in the error state.
-pub extern "C" fn CResult_NodeFeaturesDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_NodeFeaturesDecodeErrorZ {
-       CResult_NodeFeaturesDecodeErrorZ {
-               contents: CResult_NodeFeaturesDecodeErrorZPtr {
+/// Creates a new CResult_RouteHintCreationErrorZ in the error state.
+pub extern "C" fn CResult_RouteHintCreationErrorZ_err(e: crate::lightning_invoice::CreationError) -> CResult_RouteHintCreationErrorZ {
+       CResult_RouteHintCreationErrorZ {
+               contents: CResult_RouteHintCreationErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_NodeFeaturesDecodeErrorZ.
-pub extern "C" fn CResult_NodeFeaturesDecodeErrorZ_free(_res: CResult_NodeFeaturesDecodeErrorZ) { }
-impl Drop for CResult_NodeFeaturesDecodeErrorZ {
+/// Frees any resources used by the CResult_RouteHintCreationErrorZ.
+pub extern "C" fn CResult_RouteHintCreationErrorZ_free(_res: CResult_RouteHintCreationErrorZ) { }
+impl Drop for CResult_RouteHintCreationErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -5588,16 +5510,16 @@ impl Drop for CResult_NodeFeaturesDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::ln::features::NodeFeatures, crate::lightning::ln::msgs::DecodeError>> for CResult_NodeFeaturesDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::features::NodeFeatures, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning_invoice::RouteHint, crate::lightning_invoice::CreationError>> for CResult_RouteHintCreationErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning_invoice::RouteHint, crate::lightning_invoice::CreationError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_NodeFeaturesDecodeErrorZPtr { result }
+                       CResult_RouteHintCreationErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_NodeFeaturesDecodeErrorZPtr { err }
+                       CResult_RouteHintCreationErrorZPtr { err }
                };
                Self {
                        contents,
@@ -5605,51 +5527,68 @@ impl From<crate::c_types::CResultTempl<crate::lightning::ln::features::NodeFeatu
                }
        }
 }
+impl Clone for CResult_RouteHintCreationErrorZ {
+       fn clone(&self) -> Self {
+               if self.result_ok {
+                       Self { result_ok: true, contents: CResult_RouteHintCreationErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning_invoice::RouteHint>::clone(unsafe { &*self.contents.result })))
+                       } }
+               } else {
+                       Self { result_ok: false, contents: CResult_RouteHintCreationErrorZPtr {
+                               err: Box::into_raw(Box::new(<crate::lightning_invoice::CreationError>::clone(unsafe { &*self.contents.err })))
+                       } }
+               }
+       }
+}
+#[no_mangle]
+/// Creates a new CResult_RouteHintCreationErrorZ which has the same data as `orig`
+/// but with all dynamically-allocated buffers duplicated in new buffers.
+pub extern "C" fn CResult_RouteHintCreationErrorZ_clone(orig: &CResult_RouteHintCreationErrorZ) -> CResult_RouteHintCreationErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_ChannelFeaturesDecodeErrorZ
-pub union CResult_ChannelFeaturesDecodeErrorZPtr {
+/// The contents of CResult_StringErrorZ
+pub union CResult_StringErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::ln::features::ChannelFeatures,
+       pub result: *mut crate::c_types::Str,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::lightning::ln::msgs::DecodeError,
+       pub err: *mut crate::c_types::Secp256k1Error,
 }
 #[repr(C)]
-/// 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_StringErrorZ represents the result of a fallible operation,
+/// containing a crate::c_types::Str on success and a crate::c_types::Secp256k1Error on failure.
 /// `result_ok` indicates the overall state, and the contents are provided via `contents`.
-pub struct CResult_ChannelFeaturesDecodeErrorZ {
-       /// The contents of this CResult_ChannelFeaturesDecodeErrorZ, accessible via either
+pub struct CResult_StringErrorZ {
+       /// The contents of this CResult_StringErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_ChannelFeaturesDecodeErrorZPtr,
-       /// Whether this CResult_ChannelFeaturesDecodeErrorZ represents a success state.
+       pub contents: CResult_StringErrorZPtr,
+       /// Whether this CResult_StringErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_ChannelFeaturesDecodeErrorZ in the success state.
-pub extern "C" fn CResult_ChannelFeaturesDecodeErrorZ_ok(o: crate::lightning::ln::features::ChannelFeatures) -> CResult_ChannelFeaturesDecodeErrorZ {
-       CResult_ChannelFeaturesDecodeErrorZ {
-               contents: CResult_ChannelFeaturesDecodeErrorZPtr {
+/// Creates a new CResult_StringErrorZ in the success state.
+pub extern "C" fn CResult_StringErrorZ_ok(o: crate::c_types::Str) -> CResult_StringErrorZ {
+       CResult_StringErrorZ {
+               contents: CResult_StringErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_ChannelFeaturesDecodeErrorZ in the error state.
-pub extern "C" fn CResult_ChannelFeaturesDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_ChannelFeaturesDecodeErrorZ {
-       CResult_ChannelFeaturesDecodeErrorZ {
-               contents: CResult_ChannelFeaturesDecodeErrorZPtr {
+/// Creates a new CResult_StringErrorZ in the error state.
+pub extern "C" fn CResult_StringErrorZ_err(e: crate::c_types::Secp256k1Error) -> CResult_StringErrorZ {
+       CResult_StringErrorZ {
+               contents: CResult_StringErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_ChannelFeaturesDecodeErrorZ.
-pub extern "C" fn CResult_ChannelFeaturesDecodeErrorZ_free(_res: CResult_ChannelFeaturesDecodeErrorZ) { }
-impl Drop for CResult_ChannelFeaturesDecodeErrorZ {
+/// Frees any resources used by the CResult_StringErrorZ.
+pub extern "C" fn CResult_StringErrorZ_free(_res: CResult_StringErrorZ) { }
+impl Drop for CResult_StringErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -5662,16 +5601,16 @@ impl Drop for CResult_ChannelFeaturesDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::ln::features::ChannelFeatures, crate::lightning::ln::msgs::DecodeError>> for CResult_ChannelFeaturesDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::features::ChannelFeatures, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::c_types::Str, crate::c_types::Secp256k1Error>> for CResult_StringErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::c_types::Str, crate::c_types::Secp256k1Error>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_ChannelFeaturesDecodeErrorZPtr { result }
+                       CResult_StringErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_ChannelFeaturesDecodeErrorZPtr { err }
+                       CResult_StringErrorZPtr { err }
                };
                Self {
                        contents,
@@ -5680,50 +5619,50 @@ impl From<crate::c_types::CResultTempl<crate::lightning::ln::features::ChannelFe
        }
 }
 #[repr(C)]
-/// The contents of CResult_InvoiceFeaturesDecodeErrorZ
-pub union CResult_InvoiceFeaturesDecodeErrorZPtr {
+/// The contents of CResult_ChannelMonitorUpdateDecodeErrorZ
+pub union CResult_ChannelMonitorUpdateDecodeErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::ln::features::InvoiceFeatures,
+       pub result: *mut crate::lightning::chain::channelmonitor::ChannelMonitorUpdate,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
        pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// 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_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`.
-pub struct CResult_InvoiceFeaturesDecodeErrorZ {
-       /// The contents of this CResult_InvoiceFeaturesDecodeErrorZ, accessible via either
+pub struct CResult_ChannelMonitorUpdateDecodeErrorZ {
+       /// The contents of this CResult_ChannelMonitorUpdateDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_InvoiceFeaturesDecodeErrorZPtr,
-       /// Whether this CResult_InvoiceFeaturesDecodeErrorZ represents a success state.
+       pub contents: CResult_ChannelMonitorUpdateDecodeErrorZPtr,
+       /// Whether this CResult_ChannelMonitorUpdateDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_InvoiceFeaturesDecodeErrorZ in the success state.
-pub extern "C" fn CResult_InvoiceFeaturesDecodeErrorZ_ok(o: crate::lightning::ln::features::InvoiceFeatures) -> CResult_InvoiceFeaturesDecodeErrorZ {
-       CResult_InvoiceFeaturesDecodeErrorZ {
-               contents: CResult_InvoiceFeaturesDecodeErrorZPtr {
+/// Creates a new CResult_ChannelMonitorUpdateDecodeErrorZ in the success state.
+pub extern "C" fn CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o: crate::lightning::chain::channelmonitor::ChannelMonitorUpdate) -> CResult_ChannelMonitorUpdateDecodeErrorZ {
+       CResult_ChannelMonitorUpdateDecodeErrorZ {
+               contents: CResult_ChannelMonitorUpdateDecodeErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_InvoiceFeaturesDecodeErrorZ in the error state.
-pub extern "C" fn CResult_InvoiceFeaturesDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_InvoiceFeaturesDecodeErrorZ {
-       CResult_InvoiceFeaturesDecodeErrorZ {
-               contents: CResult_InvoiceFeaturesDecodeErrorZPtr {
+/// Creates a new CResult_ChannelMonitorUpdateDecodeErrorZ in the error state.
+pub extern "C" fn CResult_ChannelMonitorUpdateDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_ChannelMonitorUpdateDecodeErrorZ {
+       CResult_ChannelMonitorUpdateDecodeErrorZ {
+               contents: CResult_ChannelMonitorUpdateDecodeErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_InvoiceFeaturesDecodeErrorZ.
-pub extern "C" fn CResult_InvoiceFeaturesDecodeErrorZ_free(_res: CResult_InvoiceFeaturesDecodeErrorZ) { }
-impl Drop for CResult_InvoiceFeaturesDecodeErrorZ {
+/// Frees any resources used by the CResult_ChannelMonitorUpdateDecodeErrorZ.
+pub extern "C" fn CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res: CResult_ChannelMonitorUpdateDecodeErrorZ) { }
+impl Drop for CResult_ChannelMonitorUpdateDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -5736,16 +5675,16 @@ impl Drop for CResult_InvoiceFeaturesDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::ln::features::InvoiceFeatures, crate::lightning::ln::msgs::DecodeError>> for CResult_InvoiceFeaturesDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::features::InvoiceFeatures, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::chain::channelmonitor::ChannelMonitorUpdate, crate::lightning::ln::msgs::DecodeError>> for CResult_ChannelMonitorUpdateDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::chain::channelmonitor::ChannelMonitorUpdate, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_InvoiceFeaturesDecodeErrorZPtr { result }
+                       CResult_ChannelMonitorUpdateDecodeErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_InvoiceFeaturesDecodeErrorZPtr { err }
+                       CResult_ChannelMonitorUpdateDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -5753,51 +5692,68 @@ impl From<crate::c_types::CResultTempl<crate::lightning::ln::features::InvoiceFe
                }
        }
 }
+impl Clone for CResult_ChannelMonitorUpdateDecodeErrorZ {
+       fn clone(&self) -> Self {
+               if self.result_ok {
+                       Self { result_ok: true, contents: CResult_ChannelMonitorUpdateDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::chain::channelmonitor::ChannelMonitorUpdate>::clone(unsafe { &*self.contents.result })))
+                       } }
+               } else {
+                       Self { result_ok: false, contents: CResult_ChannelMonitorUpdateDecodeErrorZPtr {
+                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
+                       } }
+               }
+       }
+}
+#[no_mangle]
+/// Creates a new CResult_ChannelMonitorUpdateDecodeErrorZ which has the same data as `orig`
+/// but with all dynamically-allocated buffers duplicated in new buffers.
+pub extern "C" fn CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig: &CResult_ChannelMonitorUpdateDecodeErrorZ) -> CResult_ChannelMonitorUpdateDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_NetAddressu8Z
-pub union CResult_NetAddressu8ZPtr {
+/// The contents of CResult_HTLCUpdateDecodeErrorZ
+pub union CResult_HTLCUpdateDecodeErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::ln::msgs::NetAddress,
+       pub result: *mut crate::lightning::chain::channelmonitor::HTLCUpdate,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut u8,
+       pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// A CResult_NetAddressu8Z represents the result of a fallible operation,
-/// containing a crate::lightning::ln::msgs::NetAddress on success and a u8 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`.
-pub struct CResult_NetAddressu8Z {
-       /// The contents of this CResult_NetAddressu8Z, accessible via either
+pub struct CResult_HTLCUpdateDecodeErrorZ {
+       /// The contents of this CResult_HTLCUpdateDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_NetAddressu8ZPtr,
-       /// Whether this CResult_NetAddressu8Z represents a success state.
+       pub contents: CResult_HTLCUpdateDecodeErrorZPtr,
+       /// Whether this CResult_HTLCUpdateDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_NetAddressu8Z in the success state.
-pub extern "C" fn CResult_NetAddressu8Z_ok(o: crate::lightning::ln::msgs::NetAddress) -> CResult_NetAddressu8Z {
-       CResult_NetAddressu8Z {
-               contents: CResult_NetAddressu8ZPtr {
+/// Creates a new CResult_HTLCUpdateDecodeErrorZ in the success state.
+pub extern "C" fn CResult_HTLCUpdateDecodeErrorZ_ok(o: crate::lightning::chain::channelmonitor::HTLCUpdate) -> CResult_HTLCUpdateDecodeErrorZ {
+       CResult_HTLCUpdateDecodeErrorZ {
+               contents: CResult_HTLCUpdateDecodeErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_NetAddressu8Z in the error state.
-pub extern "C" fn CResult_NetAddressu8Z_err(e: u8) -> CResult_NetAddressu8Z {
-       CResult_NetAddressu8Z {
-               contents: CResult_NetAddressu8ZPtr {
+/// Creates a new CResult_HTLCUpdateDecodeErrorZ in the error state.
+pub extern "C" fn CResult_HTLCUpdateDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_HTLCUpdateDecodeErrorZ {
+       CResult_HTLCUpdateDecodeErrorZ {
+               contents: CResult_HTLCUpdateDecodeErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_NetAddressu8Z.
-pub extern "C" fn CResult_NetAddressu8Z_free(_res: CResult_NetAddressu8Z) { }
-impl Drop for CResult_NetAddressu8Z {
+/// Frees any resources used by the CResult_HTLCUpdateDecodeErrorZ.
+pub extern "C" fn CResult_HTLCUpdateDecodeErrorZ_free(_res: CResult_HTLCUpdateDecodeErrorZ) { }
+impl Drop for CResult_HTLCUpdateDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -5810,16 +5766,16 @@ impl Drop for CResult_NetAddressu8Z {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::NetAddress, u8>> for CResult_NetAddressu8Z {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::NetAddress, u8>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::chain::channelmonitor::HTLCUpdate, crate::lightning::ln::msgs::DecodeError>> for CResult_HTLCUpdateDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::chain::channelmonitor::HTLCUpdate, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_NetAddressu8ZPtr { result }
+                       CResult_HTLCUpdateDecodeErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_NetAddressu8ZPtr { err }
+                       CResult_HTLCUpdateDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -5827,73 +5783,69 @@ impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::NetAddress, u
                }
        }
 }
-impl Clone for CResult_NetAddressu8Z {
+impl Clone for CResult_HTLCUpdateDecodeErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_NetAddressu8ZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::NetAddress>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_HTLCUpdateDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::chain::channelmonitor::HTLCUpdate>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_NetAddressu8ZPtr {
-                               err: Box::into_raw(Box::new(<u8>::clone(unsafe { &*self.contents.err })))
+                       Self { result_ok: false, contents: CResult_HTLCUpdateDecodeErrorZPtr {
+                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_NetAddressu8Z which has the same data as `orig`
+/// Creates a new CResult_HTLCUpdateDecodeErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_NetAddressu8Z_clone(orig: &CResult_NetAddressu8Z) -> CResult_NetAddressu8Z { orig.clone() }
+pub extern "C" fn CResult_HTLCUpdateDecodeErrorZ_clone(orig: &CResult_HTLCUpdateDecodeErrorZ) -> CResult_HTLCUpdateDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_CResult_NetAddressu8ZDecodeErrorZ
-pub union CResult_CResult_NetAddressu8ZDecodeErrorZPtr {
-       /// A pointer to the contents in the success state.
-       /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::c_types::derived::CResult_NetAddressu8Z,
+/// The contents of CResult_NoneMonitorUpdateErrorZ
+pub union CResult_NoneMonitorUpdateErrorZPtr {
+       /// Note that this value is always NULL, as there are no contents in the OK variant
+       pub result: *mut std::ffi::c_void,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::lightning::ln::msgs::DecodeError,
+       pub err: *mut crate::lightning::chain::channelmonitor::MonitorUpdateError,
 }
 #[repr(C)]
-/// 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_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`.
-pub struct CResult_CResult_NetAddressu8ZDecodeErrorZ {
-       /// The contents of this CResult_CResult_NetAddressu8ZDecodeErrorZ, accessible via either
+pub struct CResult_NoneMonitorUpdateErrorZ {
+       /// The contents of this CResult_NoneMonitorUpdateErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_CResult_NetAddressu8ZDecodeErrorZPtr,
-       /// Whether this CResult_CResult_NetAddressu8ZDecodeErrorZ represents a success state.
+       pub contents: CResult_NoneMonitorUpdateErrorZPtr,
+       /// Whether this CResult_NoneMonitorUpdateErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_CResult_NetAddressu8ZDecodeErrorZ in the success state.
-pub extern "C" fn CResult_CResult_NetAddressu8ZDecodeErrorZ_ok(o: crate::c_types::derived::CResult_NetAddressu8Z) -> CResult_CResult_NetAddressu8ZDecodeErrorZ {
-       CResult_CResult_NetAddressu8ZDecodeErrorZ {
-               contents: CResult_CResult_NetAddressu8ZDecodeErrorZPtr {
-                       result: Box::into_raw(Box::new(o)),
+/// Creates a new CResult_NoneMonitorUpdateErrorZ in the success state.
+pub extern "C" fn CResult_NoneMonitorUpdateErrorZ_ok() -> CResult_NoneMonitorUpdateErrorZ {
+       CResult_NoneMonitorUpdateErrorZ {
+               contents: CResult_NoneMonitorUpdateErrorZPtr {
+                       result: std::ptr::null_mut(),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_CResult_NetAddressu8ZDecodeErrorZ in the error state.
-pub extern "C" fn CResult_CResult_NetAddressu8ZDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_CResult_NetAddressu8ZDecodeErrorZ {
-       CResult_CResult_NetAddressu8ZDecodeErrorZ {
-               contents: CResult_CResult_NetAddressu8ZDecodeErrorZPtr {
+/// Creates a new CResult_NoneMonitorUpdateErrorZ in the error state.
+pub extern "C" fn CResult_NoneMonitorUpdateErrorZ_err(e: crate::lightning::chain::channelmonitor::MonitorUpdateError) -> CResult_NoneMonitorUpdateErrorZ {
+       CResult_NoneMonitorUpdateErrorZ {
+               contents: CResult_NoneMonitorUpdateErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_CResult_NetAddressu8ZDecodeErrorZ.
-pub extern "C" fn CResult_CResult_NetAddressu8ZDecodeErrorZ_free(_res: CResult_CResult_NetAddressu8ZDecodeErrorZ) { }
-impl Drop for CResult_CResult_NetAddressu8ZDecodeErrorZ {
+/// Frees any resources used by the CResult_NoneMonitorUpdateErrorZ.
+pub extern "C" fn CResult_NoneMonitorUpdateErrorZ_free(_res: CResult_NoneMonitorUpdateErrorZ) { }
+impl Drop for CResult_NoneMonitorUpdateErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
-                       if unsafe { !(self.contents.result as *mut ()).is_null() } {
-                               let _ = unsafe { Box::from_raw(self.contents.result) };
-                       }
                } else {
                        if unsafe { !(self.contents.err as *mut ()).is_null() } {
                                let _ = unsafe { Box::from_raw(self.contents.err) };
@@ -5901,16 +5853,16 @@ impl Drop for CResult_CResult_NetAddressu8ZDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::c_types::derived::CResult_NetAddressu8Z, crate::lightning::ln::msgs::DecodeError>> for CResult_CResult_NetAddressu8ZDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::c_types::derived::CResult_NetAddressu8Z, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<(), crate::lightning::chain::channelmonitor::MonitorUpdateError>> for CResult_NoneMonitorUpdateErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<(), crate::lightning::chain::channelmonitor::MonitorUpdateError>) -> Self {
                let contents = if o.result_ok {
-                       let result = unsafe { o.contents.result };
-                       unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_CResult_NetAddressu8ZDecodeErrorZPtr { result }
+                       let _ = unsafe { Box::from_raw(o.contents.result) };
+                       o.contents.result = std::ptr::null_mut();
+                       CResult_NoneMonitorUpdateErrorZPtr { result: std::ptr::null_mut() }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_CResult_NetAddressu8ZDecodeErrorZPtr { err }
+                       CResult_NoneMonitorUpdateErrorZPtr { err }
                };
                Self {
                        contents,
@@ -5918,138 +5870,219 @@ impl From<crate::c_types::CResultTempl<crate::c_types::derived::CResult_NetAddre
                }
        }
 }
-impl Clone for CResult_CResult_NetAddressu8ZDecodeErrorZ {
+impl Clone for CResult_NoneMonitorUpdateErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_CResult_NetAddressu8ZDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::c_types::derived::CResult_NetAddressu8Z>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_NoneMonitorUpdateErrorZPtr {
+                               result: std::ptr::null_mut()
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_CResult_NetAddressu8ZDecodeErrorZPtr {
-                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
+                       Self { result_ok: false, contents: CResult_NoneMonitorUpdateErrorZPtr {
+                               err: Box::into_raw(Box::new(<crate::lightning::chain::channelmonitor::MonitorUpdateError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_CResult_NetAddressu8ZDecodeErrorZ which has the same data as `orig`
+/// Creates a new CResult_NoneMonitorUpdateErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_CResult_NetAddressu8ZDecodeErrorZ_clone(orig: &CResult_CResult_NetAddressu8ZDecodeErrorZ) -> CResult_CResult_NetAddressu8ZDecodeErrorZ { orig.clone() }
+pub extern "C" fn CResult_NoneMonitorUpdateErrorZ_clone(orig: &CResult_NoneMonitorUpdateErrorZ) -> CResult_NoneMonitorUpdateErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_NetAddressDecodeErrorZ
-pub union CResult_NetAddressDecodeErrorZPtr {
-       /// A pointer to the contents in the success state.
-       /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::ln::msgs::NetAddress,
-       /// A pointer to the contents in the error state.
-       /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::lightning::ln::msgs::DecodeError,
+/// A tuple of 2 elements. See the individual fields for the types contained.
+pub struct C2Tuple_OutPointScriptZ {
+       /// The element at position 0
+       pub a: crate::lightning::chain::transaction::OutPoint,
+       /// The element at position 1
+       pub b: crate::c_types::derived::CVec_u8Z,
+}
+impl From<(crate::lightning::chain::transaction::OutPoint, crate::c_types::derived::CVec_u8Z)> for C2Tuple_OutPointScriptZ {
+       fn from (tup: (crate::lightning::chain::transaction::OutPoint, crate::c_types::derived::CVec_u8Z)) -> Self {
+               Self {
+                       a: tup.0,
+                       b: tup.1,
+               }
+       }
+}
+impl C2Tuple_OutPointScriptZ {
+       #[allow(unused)] pub(crate) fn to_rust(mut self) -> (crate::lightning::chain::transaction::OutPoint, crate::c_types::derived::CVec_u8Z) {
+               (self.a, self.b)
+       }
+}
+impl Clone for C2Tuple_OutPointScriptZ {
+       fn clone(&self) -> Self {
+               Self {
+                       a: self.a.clone(),
+                       b: self.b.clone(),
+               }
+       }
+}
+#[no_mangle]
+/// Creates a new tuple which has the same data as `orig`
+/// but with all dynamically-allocated buffers duplicated in new buffers.
+pub extern "C" fn C2Tuple_OutPointScriptZ_clone(orig: &C2Tuple_OutPointScriptZ) -> C2Tuple_OutPointScriptZ { orig.clone() }
+/// Creates a new C2Tuple_OutPointScriptZ from the contained elements.
+#[no_mangle]
+pub extern "C" fn C2Tuple_OutPointScriptZ_new(a: crate::lightning::chain::transaction::OutPoint, b: crate::c_types::derived::CVec_u8Z) -> C2Tuple_OutPointScriptZ {
+       C2Tuple_OutPointScriptZ { a, b, }
+}
+
+#[no_mangle]
+/// Frees any resources used by the C2Tuple_OutPointScriptZ.
+pub extern "C" fn C2Tuple_OutPointScriptZ_free(_res: C2Tuple_OutPointScriptZ) { }
+#[repr(C)]
+/// A tuple of 2 elements. See the individual fields for the types contained.
+pub struct C2Tuple_u32ScriptZ {
+       /// The element at position 0
+       pub a: u32,
+       /// The element at position 1
+       pub b: crate::c_types::derived::CVec_u8Z,
+}
+impl From<(u32, crate::c_types::derived::CVec_u8Z)> for C2Tuple_u32ScriptZ {
+       fn from (tup: (u32, crate::c_types::derived::CVec_u8Z)) -> Self {
+               Self {
+                       a: tup.0,
+                       b: tup.1,
+               }
+       }
+}
+impl C2Tuple_u32ScriptZ {
+       #[allow(unused)] pub(crate) fn to_rust(mut self) -> (u32, crate::c_types::derived::CVec_u8Z) {
+               (self.a, self.b)
+       }
+}
+impl Clone for C2Tuple_u32ScriptZ {
+       fn clone(&self) -> Self {
+               Self {
+                       a: self.a.clone(),
+                       b: self.b.clone(),
+               }
+       }
+}
+#[no_mangle]
+/// Creates a new tuple which has the same data as `orig`
+/// but with all dynamically-allocated buffers duplicated in new buffers.
+pub extern "C" fn C2Tuple_u32ScriptZ_clone(orig: &C2Tuple_u32ScriptZ) -> C2Tuple_u32ScriptZ { orig.clone() }
+/// Creates a new C2Tuple_u32ScriptZ from the contained elements.
+#[no_mangle]
+pub extern "C" fn C2Tuple_u32ScriptZ_new(a: u32, b: crate::c_types::derived::CVec_u8Z) -> C2Tuple_u32ScriptZ {
+       C2Tuple_u32ScriptZ { a, b, }
 }
+
+#[no_mangle]
+/// Frees any resources used by the C2Tuple_u32ScriptZ.
+pub extern "C" fn C2Tuple_u32ScriptZ_free(_res: C2Tuple_u32ScriptZ) { }
 #[repr(C)]
-/// A CResult_NetAddressDecodeErrorZ represents the result of a fallible operation,
-/// containing a crate::lightning::ln::msgs::NetAddress on success and a crate::lightning::ln::msgs::DecodeError on failure.
-/// `result_ok` indicates the overall state, and the contents are provided via `contents`.
-pub struct CResult_NetAddressDecodeErrorZ {
-       /// The contents of this CResult_NetAddressDecodeErrorZ, accessible via either
-       /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_NetAddressDecodeErrorZPtr,
-       /// Whether this CResult_NetAddressDecodeErrorZ represents a success state.
-       pub result_ok: bool,
+/// A dynamically-allocated array of crate::c_types::derived::C2Tuple_u32ScriptZs of arbitrary size.
+/// This corresponds to std::vector in C++
+pub struct CVec_C2Tuple_u32ScriptZZ {
+       /// The elements in the array.
+       /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+       pub data: *mut crate::c_types::derived::C2Tuple_u32ScriptZ,
+       /// The number of elements pointed to by `data`.
+       pub datalen: usize
 }
-#[no_mangle]
-/// Creates a new CResult_NetAddressDecodeErrorZ in the success state.
-pub extern "C" fn CResult_NetAddressDecodeErrorZ_ok(o: crate::lightning::ln::msgs::NetAddress) -> CResult_NetAddressDecodeErrorZ {
-       CResult_NetAddressDecodeErrorZ {
-               contents: CResult_NetAddressDecodeErrorZPtr {
-                       result: Box::into_raw(Box::new(o)),
-               },
-               result_ok: true,
+impl CVec_C2Tuple_u32ScriptZZ {
+       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::c_types::derived::C2Tuple_u32ScriptZ> {
+               if self.datalen == 0 { return Vec::new(); }
+               let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
+               self.data = std::ptr::null_mut();
+               self.datalen = 0;
+               ret
+       }
+       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::c_types::derived::C2Tuple_u32ScriptZ] {
+               unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
        }
 }
-#[no_mangle]
-/// Creates a new CResult_NetAddressDecodeErrorZ in the error state.
-pub extern "C" fn CResult_NetAddressDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_NetAddressDecodeErrorZ {
-       CResult_NetAddressDecodeErrorZ {
-               contents: CResult_NetAddressDecodeErrorZPtr {
-                       err: Box::into_raw(Box::new(e)),
-               },
-               result_ok: false,
+impl From<Vec<crate::c_types::derived::C2Tuple_u32ScriptZ>> for CVec_C2Tuple_u32ScriptZZ {
+       fn from(v: Vec<crate::c_types::derived::C2Tuple_u32ScriptZ>) -> Self {
+               let datalen = v.len();
+               let data = Box::into_raw(v.into_boxed_slice());
+               Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_NetAddressDecodeErrorZ.
-pub extern "C" fn CResult_NetAddressDecodeErrorZ_free(_res: CResult_NetAddressDecodeErrorZ) { }
-impl Drop for CResult_NetAddressDecodeErrorZ {
+/// Frees the buffer pointed to by `data` if `datalen` is non-0.
+pub extern "C" fn CVec_C2Tuple_u32ScriptZZ_free(_res: CVec_C2Tuple_u32ScriptZZ) { }
+impl Drop for CVec_C2Tuple_u32ScriptZZ {
        fn drop(&mut self) {
-               if self.result_ok {
-                       if unsafe { !(self.contents.result as *mut ()).is_null() } {
-                               let _ = unsafe { Box::from_raw(self.contents.result) };
-                       }
-               } else {
-                       if unsafe { !(self.contents.err as *mut ()).is_null() } {
-                               let _ = unsafe { Box::from_raw(self.contents.err) };
-                       }
-               }
+               if self.datalen == 0 { return; }
+               unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::NetAddress, crate::lightning::ln::msgs::DecodeError>> for CResult_NetAddressDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::NetAddress, crate::lightning::ln::msgs::DecodeError>) -> Self {
-               let contents = if o.result_ok {
-                       let result = unsafe { o.contents.result };
-                       unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_NetAddressDecodeErrorZPtr { result }
-               } else {
-                       let err = unsafe { o.contents.err };
-                       unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_NetAddressDecodeErrorZPtr { err }
-               };
+impl Clone for CVec_C2Tuple_u32ScriptZZ {
+       fn clone(&self) -> Self {
+               let mut res = Vec::new();
+               if self.datalen == 0 { return Self::from(res); }
+               res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
+               Self::from(res)
+       }
+}
+#[repr(C)]
+/// A tuple of 2 elements. See the individual fields for the types contained.
+pub struct C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ {
+       /// The element at position 0
+       pub a: crate::c_types::ThirtyTwoBytes,
+       /// The element at position 1
+       pub b: crate::c_types::derived::CVec_C2Tuple_u32ScriptZZ,
+}
+impl From<(crate::c_types::ThirtyTwoBytes, crate::c_types::derived::CVec_C2Tuple_u32ScriptZZ)> for C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ {
+       fn from (tup: (crate::c_types::ThirtyTwoBytes, crate::c_types::derived::CVec_C2Tuple_u32ScriptZZ)) -> Self {
                Self {
-                       contents,
-                       result_ok: o.result_ok,
+                       a: tup.0,
+                       b: tup.1,
                }
        }
 }
-impl Clone for CResult_NetAddressDecodeErrorZ {
+impl C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ {
+       #[allow(unused)] pub(crate) fn to_rust(mut self) -> (crate::c_types::ThirtyTwoBytes, crate::c_types::derived::CVec_C2Tuple_u32ScriptZZ) {
+               (self.a, self.b)
+       }
+}
+impl Clone for C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ {
        fn clone(&self) -> Self {
-               if self.result_ok {
-                       Self { result_ok: true, contents: CResult_NetAddressDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::NetAddress>::clone(unsafe { &*self.contents.result })))
-                       } }
-               } else {
-                       Self { result_ok: false, contents: CResult_NetAddressDecodeErrorZPtr {
-                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
-                       } }
+               Self {
+                       a: self.a.clone(),
+                       b: self.b.clone(),
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_NetAddressDecodeErrorZ which has the same data as `orig`
+/// Creates a new tuple which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_NetAddressDecodeErrorZ_clone(orig: &CResult_NetAddressDecodeErrorZ) -> CResult_NetAddressDecodeErrorZ { orig.clone() }
+pub extern "C" fn C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(orig: &C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ) -> C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ { orig.clone() }
+/// Creates a new C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ from the contained elements.
+#[no_mangle]
+pub extern "C" fn C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a: crate::c_types::ThirtyTwoBytes, b: crate::c_types::derived::CVec_C2Tuple_u32ScriptZZ) -> C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ {
+       C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ { a, b, }
+}
+
+#[no_mangle]
+/// Frees any resources used by the C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ.
+pub extern "C" fn C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res: C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ) { }
 #[repr(C)]
-/// A dynamically-allocated array of crate::lightning::ln::msgs::UpdateAddHTLCs of arbitrary size.
+/// A dynamically-allocated array of crate::c_types::derived::C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZs of arbitrary size.
 /// This corresponds to std::vector in C++
-pub struct CVec_UpdateAddHTLCZ {
+pub struct CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ {
        /// The elements in the array.
        /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
-       pub data: *mut crate::lightning::ln::msgs::UpdateAddHTLC,
+       pub data: *mut crate::c_types::derived::C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ,
        /// The number of elements pointed to by `data`.
        pub datalen: usize
 }
-impl CVec_UpdateAddHTLCZ {
-       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::lightning::ln::msgs::UpdateAddHTLC> {
+impl CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ {
+       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::c_types::derived::C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ> {
                if self.datalen == 0 { return Vec::new(); }
                let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
                self.data = std::ptr::null_mut();
                self.datalen = 0;
                ret
        }
-       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::lightning::ln::msgs::UpdateAddHTLC] {
+       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::c_types::derived::C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ] {
                unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
        }
 }
-impl From<Vec<crate::lightning::ln::msgs::UpdateAddHTLC>> for CVec_UpdateAddHTLCZ {
-       fn from(v: Vec<crate::lightning::ln::msgs::UpdateAddHTLC>) -> Self {
+impl From<Vec<crate::c_types::derived::C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ>> for CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ {
+       fn from(v: Vec<crate::c_types::derived::C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ>) -> Self {
                let datalen = v.len();
                let data = Box::into_raw(v.into_boxed_slice());
                Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
@@ -6057,14 +6090,14 @@ impl From<Vec<crate::lightning::ln::msgs::UpdateAddHTLC>> for CVec_UpdateAddHTLC
 }
 #[no_mangle]
 /// Frees the buffer pointed to by `data` if `datalen` is non-0.
-pub extern "C" fn CVec_UpdateAddHTLCZ_free(_res: CVec_UpdateAddHTLCZ) { }
-impl Drop for CVec_UpdateAddHTLCZ {
+pub extern "C" fn CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res: CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ) { }
+impl Drop for CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ {
        fn drop(&mut self) {
                if self.datalen == 0 { return; }
                unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
        }
 }
-impl Clone for CVec_UpdateAddHTLCZ {
+impl Clone for CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ {
        fn clone(&self) -> Self {
                let mut res = Vec::new();
                if self.datalen == 0 { return Self::from(res); }
@@ -6073,29 +6106,29 @@ impl Clone for CVec_UpdateAddHTLCZ {
        }
 }
 #[repr(C)]
-/// A dynamically-allocated array of crate::lightning::ln::msgs::UpdateFulfillHTLCs of arbitrary size.
+/// A dynamically-allocated array of crate::lightning::util::events::Events of arbitrary size.
 /// This corresponds to std::vector in C++
-pub struct CVec_UpdateFulfillHTLCZ {
+pub struct CVec_EventZ {
        /// The elements in the array.
        /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
-       pub data: *mut crate::lightning::ln::msgs::UpdateFulfillHTLC,
+       pub data: *mut crate::lightning::util::events::Event,
        /// The number of elements pointed to by `data`.
        pub datalen: usize
 }
-impl CVec_UpdateFulfillHTLCZ {
-       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::lightning::ln::msgs::UpdateFulfillHTLC> {
+impl CVec_EventZ {
+       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::lightning::util::events::Event> {
                if self.datalen == 0 { return Vec::new(); }
                let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
                self.data = std::ptr::null_mut();
                self.datalen = 0;
                ret
        }
-       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::lightning::ln::msgs::UpdateFulfillHTLC] {
+       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::lightning::util::events::Event] {
                unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
        }
 }
-impl From<Vec<crate::lightning::ln::msgs::UpdateFulfillHTLC>> for CVec_UpdateFulfillHTLCZ {
-       fn from(v: Vec<crate::lightning::ln::msgs::UpdateFulfillHTLC>) -> Self {
+impl From<Vec<crate::lightning::util::events::Event>> for CVec_EventZ {
+       fn from(v: Vec<crate::lightning::util::events::Event>) -> Self {
                let datalen = v.len();
                let data = Box::into_raw(v.into_boxed_slice());
                Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
@@ -6103,14 +6136,14 @@ impl From<Vec<crate::lightning::ln::msgs::UpdateFulfillHTLC>> for CVec_UpdateFul
 }
 #[no_mangle]
 /// Frees the buffer pointed to by `data` if `datalen` is non-0.
-pub extern "C" fn CVec_UpdateFulfillHTLCZ_free(_res: CVec_UpdateFulfillHTLCZ) { }
-impl Drop for CVec_UpdateFulfillHTLCZ {
+pub extern "C" fn CVec_EventZ_free(_res: CVec_EventZ) { }
+impl Drop for CVec_EventZ {
        fn drop(&mut self) {
                if self.datalen == 0 { return; }
                unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
        }
 }
-impl Clone for CVec_UpdateFulfillHTLCZ {
+impl Clone for CVec_EventZ {
        fn clone(&self) -> Self {
                let mut res = Vec::new();
                if self.datalen == 0 { return Self::from(res); }
@@ -6119,29 +6152,29 @@ impl Clone for CVec_UpdateFulfillHTLCZ {
        }
 }
 #[repr(C)]
-/// A dynamically-allocated array of crate::lightning::ln::msgs::UpdateFailHTLCs of arbitrary size.
+/// A dynamically-allocated array of crate::c_types::Transactions of arbitrary size.
 /// This corresponds to std::vector in C++
-pub struct CVec_UpdateFailHTLCZ {
+pub struct CVec_TransactionZ {
        /// The elements in the array.
        /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
-       pub data: *mut crate::lightning::ln::msgs::UpdateFailHTLC,
+       pub data: *mut crate::c_types::Transaction,
        /// The number of elements pointed to by `data`.
        pub datalen: usize
 }
-impl CVec_UpdateFailHTLCZ {
-       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::lightning::ln::msgs::UpdateFailHTLC> {
+impl CVec_TransactionZ {
+       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::c_types::Transaction> {
                if self.datalen == 0 { return Vec::new(); }
                let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
                self.data = std::ptr::null_mut();
                self.datalen = 0;
                ret
        }
-       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::lightning::ln::msgs::UpdateFailHTLC] {
+       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::c_types::Transaction] {
                unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
        }
 }
-impl From<Vec<crate::lightning::ln::msgs::UpdateFailHTLC>> for CVec_UpdateFailHTLCZ {
-       fn from(v: Vec<crate::lightning::ln::msgs::UpdateFailHTLC>) -> Self {
+impl From<Vec<crate::c_types::Transaction>> for CVec_TransactionZ {
+       fn from(v: Vec<crate::c_types::Transaction>) -> Self {
                let datalen = v.len();
                let data = Box::into_raw(v.into_boxed_slice());
                Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
@@ -6149,14 +6182,14 @@ impl From<Vec<crate::lightning::ln::msgs::UpdateFailHTLC>> for CVec_UpdateFailHT
 }
 #[no_mangle]
 /// Frees the buffer pointed to by `data` if `datalen` is non-0.
-pub extern "C" fn CVec_UpdateFailHTLCZ_free(_res: CVec_UpdateFailHTLCZ) { }
-impl Drop for CVec_UpdateFailHTLCZ {
+pub extern "C" fn CVec_TransactionZ_free(_res: CVec_TransactionZ) { }
+impl Drop for CVec_TransactionZ {
        fn drop(&mut self) {
                if self.datalen == 0 { return; }
                unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
        }
 }
-impl Clone for CVec_UpdateFailHTLCZ {
+impl Clone for CVec_TransactionZ {
        fn clone(&self) -> Self {
                let mut res = Vec::new();
                if self.datalen == 0 { return Self::from(res); }
@@ -6165,29 +6198,71 @@ impl Clone for CVec_UpdateFailHTLCZ {
        }
 }
 #[repr(C)]
-/// A dynamically-allocated array of crate::lightning::ln::msgs::UpdateFailMalformedHTLCs of arbitrary size.
+/// A tuple of 2 elements. See the individual fields for the types contained.
+pub struct C2Tuple_u32TxOutZ {
+       /// The element at position 0
+       pub a: u32,
+       /// The element at position 1
+       pub b: crate::c_types::TxOut,
+}
+impl From<(u32, crate::c_types::TxOut)> for C2Tuple_u32TxOutZ {
+       fn from (tup: (u32, crate::c_types::TxOut)) -> Self {
+               Self {
+                       a: tup.0,
+                       b: tup.1,
+               }
+       }
+}
+impl C2Tuple_u32TxOutZ {
+       #[allow(unused)] pub(crate) fn to_rust(mut self) -> (u32, crate::c_types::TxOut) {
+               (self.a, self.b)
+       }
+}
+impl Clone for C2Tuple_u32TxOutZ {
+       fn clone(&self) -> Self {
+               Self {
+                       a: self.a.clone(),
+                       b: self.b.clone(),
+               }
+       }
+}
+#[no_mangle]
+/// Creates a new tuple which has the same data as `orig`
+/// but with all dynamically-allocated buffers duplicated in new buffers.
+pub extern "C" fn C2Tuple_u32TxOutZ_clone(orig: &C2Tuple_u32TxOutZ) -> C2Tuple_u32TxOutZ { orig.clone() }
+/// Creates a new C2Tuple_u32TxOutZ from the contained elements.
+#[no_mangle]
+pub extern "C" fn C2Tuple_u32TxOutZ_new(a: u32, b: crate::c_types::TxOut) -> C2Tuple_u32TxOutZ {
+       C2Tuple_u32TxOutZ { a, b, }
+}
+
+#[no_mangle]
+/// Frees any resources used by the C2Tuple_u32TxOutZ.
+pub extern "C" fn C2Tuple_u32TxOutZ_free(_res: C2Tuple_u32TxOutZ) { }
+#[repr(C)]
+/// A dynamically-allocated array of crate::c_types::derived::C2Tuple_u32TxOutZs of arbitrary size.
 /// This corresponds to std::vector in C++
-pub struct CVec_UpdateFailMalformedHTLCZ {
+pub struct CVec_C2Tuple_u32TxOutZZ {
        /// The elements in the array.
        /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
-       pub data: *mut crate::lightning::ln::msgs::UpdateFailMalformedHTLC,
+       pub data: *mut crate::c_types::derived::C2Tuple_u32TxOutZ,
        /// The number of elements pointed to by `data`.
        pub datalen: usize
 }
-impl CVec_UpdateFailMalformedHTLCZ {
-       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::lightning::ln::msgs::UpdateFailMalformedHTLC> {
+impl CVec_C2Tuple_u32TxOutZZ {
+       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::c_types::derived::C2Tuple_u32TxOutZ> {
                if self.datalen == 0 { return Vec::new(); }
                let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
                self.data = std::ptr::null_mut();
                self.datalen = 0;
                ret
        }
-       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::lightning::ln::msgs::UpdateFailMalformedHTLC] {
+       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::c_types::derived::C2Tuple_u32TxOutZ] {
                unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
        }
-}
-impl From<Vec<crate::lightning::ln::msgs::UpdateFailMalformedHTLC>> for CVec_UpdateFailMalformedHTLCZ {
-       fn from(v: Vec<crate::lightning::ln::msgs::UpdateFailMalformedHTLC>) -> Self {
+}
+impl From<Vec<crate::c_types::derived::C2Tuple_u32TxOutZ>> for CVec_C2Tuple_u32TxOutZZ {
+       fn from(v: Vec<crate::c_types::derived::C2Tuple_u32TxOutZ>) -> Self {
                let datalen = v.len();
                let data = Box::into_raw(v.into_boxed_slice());
                Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
@@ -6195,14 +6270,14 @@ impl From<Vec<crate::lightning::ln::msgs::UpdateFailMalformedHTLC>> for CVec_Upd
 }
 #[no_mangle]
 /// Frees the buffer pointed to by `data` if `datalen` is non-0.
-pub extern "C" fn CVec_UpdateFailMalformedHTLCZ_free(_res: CVec_UpdateFailMalformedHTLCZ) { }
-impl Drop for CVec_UpdateFailMalformedHTLCZ {
+pub extern "C" fn CVec_C2Tuple_u32TxOutZZ_free(_res: CVec_C2Tuple_u32TxOutZZ) { }
+impl Drop for CVec_C2Tuple_u32TxOutZZ {
        fn drop(&mut self) {
                if self.datalen == 0 { return; }
                unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
        }
 }
-impl Clone for CVec_UpdateFailMalformedHTLCZ {
+impl Clone for CVec_C2Tuple_u32TxOutZZ {
        fn clone(&self) -> Self {
                let mut res = Vec::new();
                if self.datalen == 0 { return Self::from(res); }
@@ -6211,232 +6286,138 @@ impl Clone for CVec_UpdateFailMalformedHTLCZ {
        }
 }
 #[repr(C)]
-/// The contents of CResult_AcceptChannelDecodeErrorZ
-pub union CResult_AcceptChannelDecodeErrorZPtr {
-       /// A pointer to the contents in the success state.
-       /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::ln::msgs::AcceptChannel,
-       /// A pointer to the contents in the error state.
-       /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::lightning::ln::msgs::DecodeError,
-}
-#[repr(C)]
-/// 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`.
-pub struct CResult_AcceptChannelDecodeErrorZ {
-       /// The contents of this CResult_AcceptChannelDecodeErrorZ, accessible via either
-       /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_AcceptChannelDecodeErrorZPtr,
-       /// Whether this CResult_AcceptChannelDecodeErrorZ represents a success state.
-       pub result_ok: bool,
-}
-#[no_mangle]
-/// Creates a new CResult_AcceptChannelDecodeErrorZ in the success state.
-pub extern "C" fn CResult_AcceptChannelDecodeErrorZ_ok(o: crate::lightning::ln::msgs::AcceptChannel) -> CResult_AcceptChannelDecodeErrorZ {
-       CResult_AcceptChannelDecodeErrorZ {
-               contents: CResult_AcceptChannelDecodeErrorZPtr {
-                       result: Box::into_raw(Box::new(o)),
-               },
-               result_ok: true,
-       }
-}
-#[no_mangle]
-/// Creates a new CResult_AcceptChannelDecodeErrorZ in the error state.
-pub extern "C" fn CResult_AcceptChannelDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_AcceptChannelDecodeErrorZ {
-       CResult_AcceptChannelDecodeErrorZ {
-               contents: CResult_AcceptChannelDecodeErrorZPtr {
-                       err: Box::into_raw(Box::new(e)),
-               },
-               result_ok: false,
-       }
+/// A tuple of 2 elements. See the individual fields for the types contained.
+pub struct C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ {
+       /// The element at position 0
+       pub a: crate::c_types::ThirtyTwoBytes,
+       /// The element at position 1
+       pub b: crate::c_types::derived::CVec_C2Tuple_u32TxOutZZ,
 }
-#[no_mangle]
-/// Frees any resources used by the CResult_AcceptChannelDecodeErrorZ.
-pub extern "C" fn CResult_AcceptChannelDecodeErrorZ_free(_res: CResult_AcceptChannelDecodeErrorZ) { }
-impl Drop for CResult_AcceptChannelDecodeErrorZ {
-       fn drop(&mut self) {
-               if self.result_ok {
-                       if unsafe { !(self.contents.result as *mut ()).is_null() } {
-                               let _ = unsafe { Box::from_raw(self.contents.result) };
-                       }
-               } else {
-                       if unsafe { !(self.contents.err as *mut ()).is_null() } {
-                               let _ = unsafe { Box::from_raw(self.contents.err) };
-                       }
+impl From<(crate::c_types::ThirtyTwoBytes, crate::c_types::derived::CVec_C2Tuple_u32TxOutZZ)> for C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ {
+       fn from (tup: (crate::c_types::ThirtyTwoBytes, crate::c_types::derived::CVec_C2Tuple_u32TxOutZZ)) -> Self {
+               Self {
+                       a: tup.0,
+                       b: tup.1,
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::AcceptChannel, crate::lightning::ln::msgs::DecodeError>> for CResult_AcceptChannelDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::AcceptChannel, crate::lightning::ln::msgs::DecodeError>) -> Self {
-               let contents = if o.result_ok {
-                       let result = unsafe { o.contents.result };
-                       unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_AcceptChannelDecodeErrorZPtr { result }
-               } else {
-                       let err = unsafe { o.contents.err };
-                       unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_AcceptChannelDecodeErrorZPtr { err }
-               };
-               Self {
-                       contents,
-                       result_ok: o.result_ok,
-               }
+impl C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ {
+       #[allow(unused)] pub(crate) fn to_rust(mut self) -> (crate::c_types::ThirtyTwoBytes, crate::c_types::derived::CVec_C2Tuple_u32TxOutZZ) {
+               (self.a, self.b)
        }
 }
-impl Clone for CResult_AcceptChannelDecodeErrorZ {
+impl Clone for C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ {
        fn clone(&self) -> Self {
-               if self.result_ok {
-                       Self { result_ok: true, contents: CResult_AcceptChannelDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::AcceptChannel>::clone(unsafe { &*self.contents.result })))
-                       } }
-               } else {
-                       Self { result_ok: false, contents: CResult_AcceptChannelDecodeErrorZPtr {
-                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
-                       } }
+               Self {
+                       a: self.a.clone(),
+                       b: self.b.clone(),
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_AcceptChannelDecodeErrorZ which has the same data as `orig`
+/// Creates a new tuple which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_AcceptChannelDecodeErrorZ_clone(orig: &CResult_AcceptChannelDecodeErrorZ) -> CResult_AcceptChannelDecodeErrorZ { orig.clone() }
-#[repr(C)]
-/// The contents of CResult_AnnouncementSignaturesDecodeErrorZ
-pub union CResult_AnnouncementSignaturesDecodeErrorZPtr {
-       /// A pointer to the contents in the success state.
-       /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::ln::msgs::AnnouncementSignatures,
-       /// A pointer to the contents in the error state.
-       /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::lightning::ln::msgs::DecodeError,
+pub extern "C" fn C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(orig: &C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ) -> C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ { orig.clone() }
+/// Creates a new C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ from the contained elements.
+#[no_mangle]
+pub extern "C" fn C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a: crate::c_types::ThirtyTwoBytes, b: crate::c_types::derived::CVec_C2Tuple_u32TxOutZZ) -> C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ {
+       C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ { a, b, }
 }
+
+#[no_mangle]
+/// Frees any resources used by the C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ.
+pub extern "C" fn C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res: C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ) { }
 #[repr(C)]
-/// 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`.
-pub struct CResult_AnnouncementSignaturesDecodeErrorZ {
-       /// The contents of this CResult_AnnouncementSignaturesDecodeErrorZ, accessible via either
-       /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_AnnouncementSignaturesDecodeErrorZPtr,
-       /// Whether this CResult_AnnouncementSignaturesDecodeErrorZ represents a success state.
-       pub result_ok: bool,
+/// A dynamically-allocated array of crate::c_types::derived::C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZs of arbitrary size.
+/// This corresponds to std::vector in C++
+pub struct CVec_TransactionOutputsZ {
+       /// The elements in the array.
+       /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+       pub data: *mut crate::c_types::derived::C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ,
+       /// The number of elements pointed to by `data`.
+       pub datalen: usize
 }
-#[no_mangle]
-/// Creates a new CResult_AnnouncementSignaturesDecodeErrorZ in the success state.
-pub extern "C" fn CResult_AnnouncementSignaturesDecodeErrorZ_ok(o: crate::lightning::ln::msgs::AnnouncementSignatures) -> CResult_AnnouncementSignaturesDecodeErrorZ {
-       CResult_AnnouncementSignaturesDecodeErrorZ {
-               contents: CResult_AnnouncementSignaturesDecodeErrorZPtr {
-                       result: Box::into_raw(Box::new(o)),
-               },
-               result_ok: true,
+impl CVec_TransactionOutputsZ {
+       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::c_types::derived::C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ> {
+               if self.datalen == 0 { return Vec::new(); }
+               let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
+               self.data = std::ptr::null_mut();
+               self.datalen = 0;
+               ret
+       }
+       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::c_types::derived::C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ] {
+               unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
        }
 }
-#[no_mangle]
-/// Creates a new CResult_AnnouncementSignaturesDecodeErrorZ in the error state.
-pub extern "C" fn CResult_AnnouncementSignaturesDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_AnnouncementSignaturesDecodeErrorZ {
-       CResult_AnnouncementSignaturesDecodeErrorZ {
-               contents: CResult_AnnouncementSignaturesDecodeErrorZPtr {
-                       err: Box::into_raw(Box::new(e)),
-               },
-               result_ok: false,
+impl From<Vec<crate::c_types::derived::C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ>> for CVec_TransactionOutputsZ {
+       fn from(v: Vec<crate::c_types::derived::C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ>) -> Self {
+               let datalen = v.len();
+               let data = Box::into_raw(v.into_boxed_slice());
+               Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_AnnouncementSignaturesDecodeErrorZ.
-pub extern "C" fn CResult_AnnouncementSignaturesDecodeErrorZ_free(_res: CResult_AnnouncementSignaturesDecodeErrorZ) { }
-impl Drop for CResult_AnnouncementSignaturesDecodeErrorZ {
+/// Frees the buffer pointed to by `data` if `datalen` is non-0.
+pub extern "C" fn CVec_TransactionOutputsZ_free(_res: CVec_TransactionOutputsZ) { }
+impl Drop for CVec_TransactionOutputsZ {
        fn drop(&mut self) {
-               if self.result_ok {
-                       if unsafe { !(self.contents.result as *mut ()).is_null() } {
-                               let _ = unsafe { Box::from_raw(self.contents.result) };
-                       }
-               } else {
-                       if unsafe { !(self.contents.err as *mut ()).is_null() } {
-                               let _ = unsafe { Box::from_raw(self.contents.err) };
-                       }
-               }
-       }
-}
-impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::AnnouncementSignatures, crate::lightning::ln::msgs::DecodeError>> for CResult_AnnouncementSignaturesDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::AnnouncementSignatures, crate::lightning::ln::msgs::DecodeError>) -> Self {
-               let contents = if o.result_ok {
-                       let result = unsafe { o.contents.result };
-                       unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_AnnouncementSignaturesDecodeErrorZPtr { result }
-               } else {
-                       let err = unsafe { o.contents.err };
-                       unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_AnnouncementSignaturesDecodeErrorZPtr { err }
-               };
-               Self {
-                       contents,
-                       result_ok: o.result_ok,
-               }
+               if self.datalen == 0 { return; }
+               unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
        }
 }
-impl Clone for CResult_AnnouncementSignaturesDecodeErrorZ {
+impl Clone for CVec_TransactionOutputsZ {
        fn clone(&self) -> Self {
-               if self.result_ok {
-                       Self { result_ok: true, contents: CResult_AnnouncementSignaturesDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::AnnouncementSignatures>::clone(unsafe { &*self.contents.result })))
-                       } }
-               } else {
-                       Self { result_ok: false, contents: CResult_AnnouncementSignaturesDecodeErrorZPtr {
-                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
-                       } }
-               }
+               let mut res = Vec::new();
+               if self.datalen == 0 { return Self::from(res); }
+               res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
+               Self::from(res)
        }
 }
-#[no_mangle]
-/// Creates a new CResult_AnnouncementSignaturesDecodeErrorZ which has the same data as `orig`
-/// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig: &CResult_AnnouncementSignaturesDecodeErrorZ) -> CResult_AnnouncementSignaturesDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_ChannelReestablishDecodeErrorZ
-pub union CResult_ChannelReestablishDecodeErrorZPtr {
+/// The contents of CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ
+pub union CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::ln::msgs::ChannelReestablish,
+       pub result: *mut crate::c_types::derived::C2Tuple_BlockHashChannelMonitorZ,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
        pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// 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_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`.
-pub struct CResult_ChannelReestablishDecodeErrorZ {
-       /// The contents of this CResult_ChannelReestablishDecodeErrorZ, accessible via either
+pub struct CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ {
+       /// The contents of this CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_ChannelReestablishDecodeErrorZPtr,
-       /// Whether this CResult_ChannelReestablishDecodeErrorZ represents a success state.
+       pub contents: CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZPtr,
+       /// Whether this CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_ChannelReestablishDecodeErrorZ in the success state.
-pub extern "C" fn CResult_ChannelReestablishDecodeErrorZ_ok(o: crate::lightning::ln::msgs::ChannelReestablish) -> CResult_ChannelReestablishDecodeErrorZ {
-       CResult_ChannelReestablishDecodeErrorZ {
-               contents: CResult_ChannelReestablishDecodeErrorZPtr {
+/// Creates a new CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ in the success state.
+pub extern "C" fn CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o: crate::c_types::derived::C2Tuple_BlockHashChannelMonitorZ) -> CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ {
+       CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ {
+               contents: CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_ChannelReestablishDecodeErrorZ in the error state.
-pub extern "C" fn CResult_ChannelReestablishDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_ChannelReestablishDecodeErrorZ {
-       CResult_ChannelReestablishDecodeErrorZ {
-               contents: CResult_ChannelReestablishDecodeErrorZPtr {
+/// Creates a new CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ in the error state.
+pub extern "C" fn CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ {
+       CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ {
+               contents: CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_ChannelReestablishDecodeErrorZ.
-pub extern "C" fn CResult_ChannelReestablishDecodeErrorZ_free(_res: CResult_ChannelReestablishDecodeErrorZ) { }
-impl Drop for CResult_ChannelReestablishDecodeErrorZ {
+/// Frees any resources used by the CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ.
+pub extern "C" fn CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res: CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ) { }
+impl Drop for CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -6449,16 +6430,16 @@ impl Drop for CResult_ChannelReestablishDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::ChannelReestablish, crate::lightning::ln::msgs::DecodeError>> for CResult_ChannelReestablishDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::ChannelReestablish, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::c_types::derived::C2Tuple_BlockHashChannelMonitorZ, crate::lightning::ln::msgs::DecodeError>> for CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::c_types::derived::C2Tuple_BlockHashChannelMonitorZ, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_ChannelReestablishDecodeErrorZPtr { result }
+                       CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_ChannelReestablishDecodeErrorZPtr { err }
+                       CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -6466,68 +6447,51 @@ impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::ChannelReesta
                }
        }
 }
-impl Clone for CResult_ChannelReestablishDecodeErrorZ {
-       fn clone(&self) -> Self {
-               if self.result_ok {
-                       Self { result_ok: true, contents: CResult_ChannelReestablishDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::ChannelReestablish>::clone(unsafe { &*self.contents.result })))
-                       } }
-               } else {
-                       Self { result_ok: false, contents: CResult_ChannelReestablishDecodeErrorZPtr {
-                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
-                       } }
-               }
-       }
-}
-#[no_mangle]
-/// Creates a new CResult_ChannelReestablishDecodeErrorZ which has the same data as `orig`
-/// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_ChannelReestablishDecodeErrorZ_clone(orig: &CResult_ChannelReestablishDecodeErrorZ) -> CResult_ChannelReestablishDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_ClosingSignedDecodeErrorZ
-pub union CResult_ClosingSignedDecodeErrorZPtr {
+/// The contents of CResult_boolLightningErrorZ
+pub union CResult_boolLightningErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::ln::msgs::ClosingSigned,
+       pub result: *mut bool,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::lightning::ln::msgs::DecodeError,
+       pub err: *mut crate::lightning::ln::msgs::LightningError,
 }
 #[repr(C)]
-/// 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_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`.
-pub struct CResult_ClosingSignedDecodeErrorZ {
-       /// The contents of this CResult_ClosingSignedDecodeErrorZ, accessible via either
+pub struct CResult_boolLightningErrorZ {
+       /// The contents of this CResult_boolLightningErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_ClosingSignedDecodeErrorZPtr,
-       /// Whether this CResult_ClosingSignedDecodeErrorZ represents a success state.
+       pub contents: CResult_boolLightningErrorZPtr,
+       /// Whether this CResult_boolLightningErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_ClosingSignedDecodeErrorZ in the success state.
-pub extern "C" fn CResult_ClosingSignedDecodeErrorZ_ok(o: crate::lightning::ln::msgs::ClosingSigned) -> CResult_ClosingSignedDecodeErrorZ {
-       CResult_ClosingSignedDecodeErrorZ {
-               contents: CResult_ClosingSignedDecodeErrorZPtr {
+/// Creates a new CResult_boolLightningErrorZ in the success state.
+pub extern "C" fn CResult_boolLightningErrorZ_ok(o: bool) -> CResult_boolLightningErrorZ {
+       CResult_boolLightningErrorZ {
+               contents: CResult_boolLightningErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_ClosingSignedDecodeErrorZ in the error state.
-pub extern "C" fn CResult_ClosingSignedDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_ClosingSignedDecodeErrorZ {
-       CResult_ClosingSignedDecodeErrorZ {
-               contents: CResult_ClosingSignedDecodeErrorZPtr {
+/// Creates a new CResult_boolLightningErrorZ in the error state.
+pub extern "C" fn CResult_boolLightningErrorZ_err(e: crate::lightning::ln::msgs::LightningError) -> CResult_boolLightningErrorZ {
+       CResult_boolLightningErrorZ {
+               contents: CResult_boolLightningErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_ClosingSignedDecodeErrorZ.
-pub extern "C" fn CResult_ClosingSignedDecodeErrorZ_free(_res: CResult_ClosingSignedDecodeErrorZ) { }
-impl Drop for CResult_ClosingSignedDecodeErrorZ {
+/// Frees any resources used by the CResult_boolLightningErrorZ.
+pub extern "C" fn CResult_boolLightningErrorZ_free(_res: CResult_boolLightningErrorZ) { }
+impl Drop for CResult_boolLightningErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -6540,16 +6504,16 @@ impl Drop for CResult_ClosingSignedDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::ClosingSigned, crate::lightning::ln::msgs::DecodeError>> for CResult_ClosingSignedDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::ClosingSigned, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<bool, crate::lightning::ln::msgs::LightningError>> for CResult_boolLightningErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<bool, crate::lightning::ln::msgs::LightningError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_ClosingSignedDecodeErrorZPtr { result }
+                       CResult_boolLightningErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_ClosingSignedDecodeErrorZPtr { err }
+                       CResult_boolLightningErrorZPtr { err }
                };
                Self {
                        contents,
@@ -6557,73 +6521,207 @@ impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::ClosingSigned
                }
        }
 }
-impl Clone for CResult_ClosingSignedDecodeErrorZ {
+impl Clone for CResult_boolLightningErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_ClosingSignedDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::ClosingSigned>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_boolLightningErrorZPtr {
+                               result: Box::into_raw(Box::new(<bool>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_ClosingSignedDecodeErrorZPtr {
-                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
+                       Self { result_ok: false, contents: CResult_boolLightningErrorZPtr {
+                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::LightningError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_ClosingSignedDecodeErrorZ which has the same data as `orig`
+/// Creates a new CResult_boolLightningErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_ClosingSignedDecodeErrorZ_clone(orig: &CResult_ClosingSignedDecodeErrorZ) -> CResult_ClosingSignedDecodeErrorZ { orig.clone() }
+pub extern "C" fn CResult_boolLightningErrorZ_clone(orig: &CResult_boolLightningErrorZ) -> CResult_boolLightningErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_CommitmentSignedDecodeErrorZ
-pub union CResult_CommitmentSignedDecodeErrorZPtr {
-       /// A pointer to the contents in the success state.
-       /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::ln::msgs::CommitmentSigned,
+/// A tuple of 3 elements. See the individual fields for the types contained.
+pub struct C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ {
+       /// The element at position 0
+       pub a: crate::lightning::ln::msgs::ChannelAnnouncement,
+       /// The element at position 1
+       pub b: crate::lightning::ln::msgs::ChannelUpdate,
+       /// The element at position 2
+       pub c: crate::lightning::ln::msgs::ChannelUpdate,
+}
+impl From<(crate::lightning::ln::msgs::ChannelAnnouncement, crate::lightning::ln::msgs::ChannelUpdate, crate::lightning::ln::msgs::ChannelUpdate)> for C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ {
+       fn from (tup: (crate::lightning::ln::msgs::ChannelAnnouncement, crate::lightning::ln::msgs::ChannelUpdate, crate::lightning::ln::msgs::ChannelUpdate)) -> Self {
+               Self {
+                       a: tup.0,
+                       b: tup.1,
+                       c: tup.2,
+               }
+       }
+}
+impl C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ {
+       #[allow(unused)] pub(crate) fn to_rust(mut self) -> (crate::lightning::ln::msgs::ChannelAnnouncement, crate::lightning::ln::msgs::ChannelUpdate, crate::lightning::ln::msgs::ChannelUpdate) {
+               (self.a, self.b, self.c)
+       }
+}
+impl Clone for C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ {
+       fn clone(&self) -> Self {
+               Self {
+                       a: self.a.clone(),
+                       b: self.b.clone(),
+                       c: self.c.clone(),
+               }
+       }
+}
+#[no_mangle]
+/// Creates a new tuple which has the same data as `orig`
+/// but with all dynamically-allocated buffers duplicated in new buffers.
+pub extern "C" fn C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig: &C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ) -> C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ { orig.clone() }
+/// Creates a new C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ from the contained elements.
+#[no_mangle]
+pub extern "C" fn C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a: crate::lightning::ln::msgs::ChannelAnnouncement, b: crate::lightning::ln::msgs::ChannelUpdate, c: crate::lightning::ln::msgs::ChannelUpdate) -> C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ {
+       C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ { a, b, c, }
+}
+
+#[no_mangle]
+/// Frees any resources used by the C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ.
+pub extern "C" fn C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res: C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ) { }
+#[repr(C)]
+/// A dynamically-allocated array of crate::c_types::derived::C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZs of arbitrary size.
+/// This corresponds to std::vector in C++
+pub struct CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
+       /// The elements in the array.
+       /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+       pub data: *mut crate::c_types::derived::C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ,
+       /// The number of elements pointed to by `data`.
+       pub datalen: usize
+}
+impl CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
+       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::c_types::derived::C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ> {
+               if self.datalen == 0 { return Vec::new(); }
+               let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
+               self.data = std::ptr::null_mut();
+               self.datalen = 0;
+               ret
+       }
+       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::c_types::derived::C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ] {
+               unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
+       }
+}
+impl From<Vec<crate::c_types::derived::C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ>> for CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
+       fn from(v: Vec<crate::c_types::derived::C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ>) -> Self {
+               let datalen = v.len();
+               let data = Box::into_raw(v.into_boxed_slice());
+               Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
+       }
+}
+#[no_mangle]
+/// Frees the buffer pointed to by `data` if `datalen` is non-0.
+pub extern "C" fn CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res: CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ) { }
+impl Drop for CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
+       fn drop(&mut self) {
+               if self.datalen == 0 { return; }
+               unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
+       }
+}
+impl Clone for CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
+       fn clone(&self) -> Self {
+               let mut res = Vec::new();
+               if self.datalen == 0 { return Self::from(res); }
+               res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
+               Self::from(res)
+       }
+}
+#[repr(C)]
+/// A dynamically-allocated array of crate::lightning::ln::msgs::NodeAnnouncements of arbitrary size.
+/// This corresponds to std::vector in C++
+pub struct CVec_NodeAnnouncementZ {
+       /// The elements in the array.
+       /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+       pub data: *mut crate::lightning::ln::msgs::NodeAnnouncement,
+       /// The number of elements pointed to by `data`.
+       pub datalen: usize
+}
+impl CVec_NodeAnnouncementZ {
+       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::lightning::ln::msgs::NodeAnnouncement> {
+               if self.datalen == 0 { return Vec::new(); }
+               let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
+               self.data = std::ptr::null_mut();
+               self.datalen = 0;
+               ret
+       }
+       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::lightning::ln::msgs::NodeAnnouncement] {
+               unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
+       }
+}
+impl From<Vec<crate::lightning::ln::msgs::NodeAnnouncement>> for CVec_NodeAnnouncementZ {
+       fn from(v: Vec<crate::lightning::ln::msgs::NodeAnnouncement>) -> Self {
+               let datalen = v.len();
+               let data = Box::into_raw(v.into_boxed_slice());
+               Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
+       }
+}
+#[no_mangle]
+/// Frees the buffer pointed to by `data` if `datalen` is non-0.
+pub extern "C" fn CVec_NodeAnnouncementZ_free(_res: CVec_NodeAnnouncementZ) { }
+impl Drop for CVec_NodeAnnouncementZ {
+       fn drop(&mut self) {
+               if self.datalen == 0 { return; }
+               unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
+       }
+}
+impl Clone for CVec_NodeAnnouncementZ {
+       fn clone(&self) -> Self {
+               let mut res = Vec::new();
+               if self.datalen == 0 { return Self::from(res); }
+               res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
+               Self::from(res)
+       }
+}
+#[repr(C)]
+/// The contents of CResult_NoneLightningErrorZ
+pub union CResult_NoneLightningErrorZPtr {
+       /// Note that this value is always NULL, as there are no contents in the OK variant
+       pub result: *mut std::ffi::c_void,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::lightning::ln::msgs::DecodeError,
+       pub err: *mut crate::lightning::ln::msgs::LightningError,
 }
 #[repr(C)]
-/// 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_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`.
-pub struct CResult_CommitmentSignedDecodeErrorZ {
-       /// The contents of this CResult_CommitmentSignedDecodeErrorZ, accessible via either
+pub struct CResult_NoneLightningErrorZ {
+       /// The contents of this CResult_NoneLightningErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_CommitmentSignedDecodeErrorZPtr,
-       /// Whether this CResult_CommitmentSignedDecodeErrorZ represents a success state.
+       pub contents: CResult_NoneLightningErrorZPtr,
+       /// Whether this CResult_NoneLightningErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_CommitmentSignedDecodeErrorZ in the success state.
-pub extern "C" fn CResult_CommitmentSignedDecodeErrorZ_ok(o: crate::lightning::ln::msgs::CommitmentSigned) -> CResult_CommitmentSignedDecodeErrorZ {
-       CResult_CommitmentSignedDecodeErrorZ {
-               contents: CResult_CommitmentSignedDecodeErrorZPtr {
-                       result: Box::into_raw(Box::new(o)),
+/// Creates a new CResult_NoneLightningErrorZ in the success state.
+pub extern "C" fn CResult_NoneLightningErrorZ_ok() -> CResult_NoneLightningErrorZ {
+       CResult_NoneLightningErrorZ {
+               contents: CResult_NoneLightningErrorZPtr {
+                       result: std::ptr::null_mut(),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_CommitmentSignedDecodeErrorZ in the error state.
-pub extern "C" fn CResult_CommitmentSignedDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_CommitmentSignedDecodeErrorZ {
-       CResult_CommitmentSignedDecodeErrorZ {
-               contents: CResult_CommitmentSignedDecodeErrorZPtr {
+/// Creates a new CResult_NoneLightningErrorZ in the error state.
+pub extern "C" fn CResult_NoneLightningErrorZ_err(e: crate::lightning::ln::msgs::LightningError) -> CResult_NoneLightningErrorZ {
+       CResult_NoneLightningErrorZ {
+               contents: CResult_NoneLightningErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_CommitmentSignedDecodeErrorZ.
-pub extern "C" fn CResult_CommitmentSignedDecodeErrorZ_free(_res: CResult_CommitmentSignedDecodeErrorZ) { }
-impl Drop for CResult_CommitmentSignedDecodeErrorZ {
+/// Frees any resources used by the CResult_NoneLightningErrorZ.
+pub extern "C" fn CResult_NoneLightningErrorZ_free(_res: CResult_NoneLightningErrorZ) { }
+impl Drop for CResult_NoneLightningErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
-                       if unsafe { !(self.contents.result as *mut ()).is_null() } {
-                               let _ = unsafe { Box::from_raw(self.contents.result) };
-                       }
                } else {
                        if unsafe { !(self.contents.err as *mut ()).is_null() } {
                                let _ = unsafe { Box::from_raw(self.contents.err) };
@@ -6631,16 +6729,16 @@ impl Drop for CResult_CommitmentSignedDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::CommitmentSigned, crate::lightning::ln::msgs::DecodeError>> for CResult_CommitmentSignedDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::CommitmentSigned, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<(), crate::lightning::ln::msgs::LightningError>> for CResult_NoneLightningErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<(), crate::lightning::ln::msgs::LightningError>) -> Self {
                let contents = if o.result_ok {
-                       let result = unsafe { o.contents.result };
-                       unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_CommitmentSignedDecodeErrorZPtr { result }
+                       let _ = unsafe { Box::from_raw(o.contents.result) };
+                       o.contents.result = std::ptr::null_mut();
+                       CResult_NoneLightningErrorZPtr { result: std::ptr::null_mut() }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_CommitmentSignedDecodeErrorZPtr { err }
+                       CResult_NoneLightningErrorZPtr { err }
                };
                Self {
                        contents,
@@ -6648,68 +6746,114 @@ impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::CommitmentSig
                }
        }
 }
-impl Clone for CResult_CommitmentSignedDecodeErrorZ {
+impl Clone for CResult_NoneLightningErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_CommitmentSignedDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::CommitmentSigned>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_NoneLightningErrorZPtr {
+                               result: std::ptr::null_mut()
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_CommitmentSignedDecodeErrorZPtr {
-                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
+                       Self { result_ok: false, contents: CResult_NoneLightningErrorZPtr {
+                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::LightningError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_CommitmentSignedDecodeErrorZ which has the same data as `orig`
+/// Creates a new CResult_NoneLightningErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_CommitmentSignedDecodeErrorZ_clone(orig: &CResult_CommitmentSignedDecodeErrorZ) -> CResult_CommitmentSignedDecodeErrorZ { orig.clone() }
+pub extern "C" fn CResult_NoneLightningErrorZ_clone(orig: &CResult_NoneLightningErrorZ) -> CResult_NoneLightningErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_FundingCreatedDecodeErrorZ
-pub union CResult_FundingCreatedDecodeErrorZPtr {
+/// A dynamically-allocated array of crate::c_types::PublicKeys of arbitrary size.
+/// This corresponds to std::vector in C++
+pub struct CVec_PublicKeyZ {
+       /// The elements in the array.
+       /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+       pub data: *mut crate::c_types::PublicKey,
+       /// The number of elements pointed to by `data`.
+       pub datalen: usize
+}
+impl CVec_PublicKeyZ {
+       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::c_types::PublicKey> {
+               if self.datalen == 0 { return Vec::new(); }
+               let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
+               self.data = std::ptr::null_mut();
+               self.datalen = 0;
+               ret
+       }
+       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::c_types::PublicKey] {
+               unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
+       }
+}
+impl From<Vec<crate::c_types::PublicKey>> for CVec_PublicKeyZ {
+       fn from(v: Vec<crate::c_types::PublicKey>) -> Self {
+               let datalen = v.len();
+               let data = Box::into_raw(v.into_boxed_slice());
+               Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
+       }
+}
+#[no_mangle]
+/// Frees the buffer pointed to by `data` if `datalen` is non-0.
+pub extern "C" fn CVec_PublicKeyZ_free(_res: CVec_PublicKeyZ) { }
+impl Drop for CVec_PublicKeyZ {
+       fn drop(&mut self) {
+               if self.datalen == 0 { return; }
+               unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
+       }
+}
+impl Clone for CVec_PublicKeyZ {
+       fn clone(&self) -> Self {
+               let mut res = Vec::new();
+               if self.datalen == 0 { return Self::from(res); }
+               res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
+               Self::from(res)
+       }
+}
+#[repr(C)]
+/// The contents of CResult_CVec_u8ZPeerHandleErrorZ
+pub union CResult_CVec_u8ZPeerHandleErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::ln::msgs::FundingCreated,
+       pub result: *mut crate::c_types::derived::CVec_u8Z,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::lightning::ln::msgs::DecodeError,
+       pub err: *mut crate::lightning::ln::peer_handler::PeerHandleError,
 }
 #[repr(C)]
-/// 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.
+/// 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`.
-pub struct CResult_FundingCreatedDecodeErrorZ {
-       /// The contents of this CResult_FundingCreatedDecodeErrorZ, accessible via either
+pub struct CResult_CVec_u8ZPeerHandleErrorZ {
+       /// The contents of this CResult_CVec_u8ZPeerHandleErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_FundingCreatedDecodeErrorZPtr,
-       /// Whether this CResult_FundingCreatedDecodeErrorZ represents a success state.
+       pub contents: CResult_CVec_u8ZPeerHandleErrorZPtr,
+       /// Whether this CResult_CVec_u8ZPeerHandleErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_FundingCreatedDecodeErrorZ in the success state.
-pub extern "C" fn CResult_FundingCreatedDecodeErrorZ_ok(o: crate::lightning::ln::msgs::FundingCreated) -> CResult_FundingCreatedDecodeErrorZ {
-       CResult_FundingCreatedDecodeErrorZ {
-               contents: CResult_FundingCreatedDecodeErrorZPtr {
+/// Creates a new CResult_CVec_u8ZPeerHandleErrorZ in the success state.
+pub extern "C" fn CResult_CVec_u8ZPeerHandleErrorZ_ok(o: crate::c_types::derived::CVec_u8Z) -> CResult_CVec_u8ZPeerHandleErrorZ {
+       CResult_CVec_u8ZPeerHandleErrorZ {
+               contents: CResult_CVec_u8ZPeerHandleErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_FundingCreatedDecodeErrorZ in the error state.
-pub extern "C" fn CResult_FundingCreatedDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_FundingCreatedDecodeErrorZ {
-       CResult_FundingCreatedDecodeErrorZ {
-               contents: CResult_FundingCreatedDecodeErrorZPtr {
+/// Creates a new CResult_CVec_u8ZPeerHandleErrorZ in the error state.
+pub extern "C" fn CResult_CVec_u8ZPeerHandleErrorZ_err(e: crate::lightning::ln::peer_handler::PeerHandleError) -> CResult_CVec_u8ZPeerHandleErrorZ {
+       CResult_CVec_u8ZPeerHandleErrorZ {
+               contents: CResult_CVec_u8ZPeerHandleErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_FundingCreatedDecodeErrorZ.
-pub extern "C" fn CResult_FundingCreatedDecodeErrorZ_free(_res: CResult_FundingCreatedDecodeErrorZ) { }
-impl Drop for CResult_FundingCreatedDecodeErrorZ {
+/// Frees any resources used by the CResult_CVec_u8ZPeerHandleErrorZ.
+pub extern "C" fn CResult_CVec_u8ZPeerHandleErrorZ_free(_res: CResult_CVec_u8ZPeerHandleErrorZ) { }
+impl Drop for CResult_CVec_u8ZPeerHandleErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -6722,16 +6866,16 @@ impl Drop for CResult_FundingCreatedDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::FundingCreated, crate::lightning::ln::msgs::DecodeError>> for CResult_FundingCreatedDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::FundingCreated, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::c_types::derived::CVec_u8Z, crate::lightning::ln::peer_handler::PeerHandleError>> for CResult_CVec_u8ZPeerHandleErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::c_types::derived::CVec_u8Z, crate::lightning::ln::peer_handler::PeerHandleError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_FundingCreatedDecodeErrorZPtr { result }
+                       CResult_CVec_u8ZPeerHandleErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_FundingCreatedDecodeErrorZPtr { err }
+                       CResult_CVec_u8ZPeerHandleErrorZPtr { err }
                };
                Self {
                        contents,
@@ -6739,73 +6883,69 @@ impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::FundingCreate
                }
        }
 }
-impl Clone for CResult_FundingCreatedDecodeErrorZ {
+impl Clone for CResult_CVec_u8ZPeerHandleErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_FundingCreatedDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::FundingCreated>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_CVec_u8ZPeerHandleErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::c_types::derived::CVec_u8Z>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_FundingCreatedDecodeErrorZPtr {
-                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
+                       Self { result_ok: false, contents: CResult_CVec_u8ZPeerHandleErrorZPtr {
+                               err: Box::into_raw(Box::new(<crate::lightning::ln::peer_handler::PeerHandleError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_FundingCreatedDecodeErrorZ which has the same data as `orig`
+/// Creates a new CResult_CVec_u8ZPeerHandleErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_FundingCreatedDecodeErrorZ_clone(orig: &CResult_FundingCreatedDecodeErrorZ) -> CResult_FundingCreatedDecodeErrorZ { orig.clone() }
+pub extern "C" fn CResult_CVec_u8ZPeerHandleErrorZ_clone(orig: &CResult_CVec_u8ZPeerHandleErrorZ) -> CResult_CVec_u8ZPeerHandleErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_FundingSignedDecodeErrorZ
-pub union CResult_FundingSignedDecodeErrorZPtr {
-       /// A pointer to the contents in the success state.
-       /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::ln::msgs::FundingSigned,
+/// The contents of CResult_NonePeerHandleErrorZ
+pub union CResult_NonePeerHandleErrorZPtr {
+       /// Note that this value is always NULL, as there are no contents in the OK variant
+       pub result: *mut std::ffi::c_void,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::lightning::ln::msgs::DecodeError,
+       pub err: *mut crate::lightning::ln::peer_handler::PeerHandleError,
 }
 #[repr(C)]
-/// 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.
+/// 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`.
-pub struct CResult_FundingSignedDecodeErrorZ {
-       /// The contents of this CResult_FundingSignedDecodeErrorZ, accessible via either
+pub struct CResult_NonePeerHandleErrorZ {
+       /// The contents of this CResult_NonePeerHandleErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_FundingSignedDecodeErrorZPtr,
-       /// Whether this CResult_FundingSignedDecodeErrorZ represents a success state.
+       pub contents: CResult_NonePeerHandleErrorZPtr,
+       /// Whether this CResult_NonePeerHandleErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_FundingSignedDecodeErrorZ in the success state.
-pub extern "C" fn CResult_FundingSignedDecodeErrorZ_ok(o: crate::lightning::ln::msgs::FundingSigned) -> CResult_FundingSignedDecodeErrorZ {
-       CResult_FundingSignedDecodeErrorZ {
-               contents: CResult_FundingSignedDecodeErrorZPtr {
-                       result: Box::into_raw(Box::new(o)),
+/// Creates a new CResult_NonePeerHandleErrorZ in the success state.
+pub extern "C" fn CResult_NonePeerHandleErrorZ_ok() -> CResult_NonePeerHandleErrorZ {
+       CResult_NonePeerHandleErrorZ {
+               contents: CResult_NonePeerHandleErrorZPtr {
+                       result: std::ptr::null_mut(),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_FundingSignedDecodeErrorZ in the error state.
-pub extern "C" fn CResult_FundingSignedDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_FundingSignedDecodeErrorZ {
-       CResult_FundingSignedDecodeErrorZ {
-               contents: CResult_FundingSignedDecodeErrorZPtr {
+/// Creates a new CResult_NonePeerHandleErrorZ in the error state.
+pub extern "C" fn CResult_NonePeerHandleErrorZ_err(e: crate::lightning::ln::peer_handler::PeerHandleError) -> CResult_NonePeerHandleErrorZ {
+       CResult_NonePeerHandleErrorZ {
+               contents: CResult_NonePeerHandleErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_FundingSignedDecodeErrorZ.
-pub extern "C" fn CResult_FundingSignedDecodeErrorZ_free(_res: CResult_FundingSignedDecodeErrorZ) { }
-impl Drop for CResult_FundingSignedDecodeErrorZ {
+/// Frees any resources used by the CResult_NonePeerHandleErrorZ.
+pub extern "C" fn CResult_NonePeerHandleErrorZ_free(_res: CResult_NonePeerHandleErrorZ) { }
+impl Drop for CResult_NonePeerHandleErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
-                       if unsafe { !(self.contents.result as *mut ()).is_null() } {
-                               let _ = unsafe { Box::from_raw(self.contents.result) };
-                       }
                } else {
                        if unsafe { !(self.contents.err as *mut ()).is_null() } {
                                let _ = unsafe { Box::from_raw(self.contents.err) };
@@ -6813,16 +6953,16 @@ impl Drop for CResult_FundingSignedDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::FundingSigned, crate::lightning::ln::msgs::DecodeError>> for CResult_FundingSignedDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::FundingSigned, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<(), crate::lightning::ln::peer_handler::PeerHandleError>> for CResult_NonePeerHandleErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<(), crate::lightning::ln::peer_handler::PeerHandleError>) -> Self {
                let contents = if o.result_ok {
-                       let result = unsafe { o.contents.result };
-                       unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_FundingSignedDecodeErrorZPtr { result }
+                       let _ = unsafe { Box::from_raw(o.contents.result) };
+                       o.contents.result = std::ptr::null_mut();
+                       CResult_NonePeerHandleErrorZPtr { result: std::ptr::null_mut() }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_FundingSignedDecodeErrorZPtr { err }
+                       CResult_NonePeerHandleErrorZPtr { err }
                };
                Self {
                        contents,
@@ -6830,68 +6970,68 @@ impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::FundingSigned
                }
        }
 }
-impl Clone for CResult_FundingSignedDecodeErrorZ {
+impl Clone for CResult_NonePeerHandleErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_FundingSignedDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::FundingSigned>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_NonePeerHandleErrorZPtr {
+                               result: std::ptr::null_mut()
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_FundingSignedDecodeErrorZPtr {
-                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
+                       Self { result_ok: false, contents: CResult_NonePeerHandleErrorZPtr {
+                               err: Box::into_raw(Box::new(<crate::lightning::ln::peer_handler::PeerHandleError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_FundingSignedDecodeErrorZ which has the same data as `orig`
+/// Creates a new CResult_NonePeerHandleErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_FundingSignedDecodeErrorZ_clone(orig: &CResult_FundingSignedDecodeErrorZ) -> CResult_FundingSignedDecodeErrorZ { orig.clone() }
+pub extern "C" fn CResult_NonePeerHandleErrorZ_clone(orig: &CResult_NonePeerHandleErrorZ) -> CResult_NonePeerHandleErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_FundingLockedDecodeErrorZ
-pub union CResult_FundingLockedDecodeErrorZPtr {
+/// The contents of CResult_boolPeerHandleErrorZ
+pub union CResult_boolPeerHandleErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::ln::msgs::FundingLocked,
+       pub result: *mut bool,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::lightning::ln::msgs::DecodeError,
+       pub err: *mut crate::lightning::ln::peer_handler::PeerHandleError,
 }
 #[repr(C)]
-/// 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_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`.
-pub struct CResult_FundingLockedDecodeErrorZ {
-       /// The contents of this CResult_FundingLockedDecodeErrorZ, accessible via either
+pub struct CResult_boolPeerHandleErrorZ {
+       /// The contents of this CResult_boolPeerHandleErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_FundingLockedDecodeErrorZPtr,
-       /// Whether this CResult_FundingLockedDecodeErrorZ represents a success state.
+       pub contents: CResult_boolPeerHandleErrorZPtr,
+       /// Whether this CResult_boolPeerHandleErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_FundingLockedDecodeErrorZ in the success state.
-pub extern "C" fn CResult_FundingLockedDecodeErrorZ_ok(o: crate::lightning::ln::msgs::FundingLocked) -> CResult_FundingLockedDecodeErrorZ {
-       CResult_FundingLockedDecodeErrorZ {
-               contents: CResult_FundingLockedDecodeErrorZPtr {
+/// Creates a new CResult_boolPeerHandleErrorZ in the success state.
+pub extern "C" fn CResult_boolPeerHandleErrorZ_ok(o: bool) -> CResult_boolPeerHandleErrorZ {
+       CResult_boolPeerHandleErrorZ {
+               contents: CResult_boolPeerHandleErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_FundingLockedDecodeErrorZ in the error state.
-pub extern "C" fn CResult_FundingLockedDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_FundingLockedDecodeErrorZ {
-       CResult_FundingLockedDecodeErrorZ {
-               contents: CResult_FundingLockedDecodeErrorZPtr {
+/// Creates a new CResult_boolPeerHandleErrorZ in the error state.
+pub extern "C" fn CResult_boolPeerHandleErrorZ_err(e: crate::lightning::ln::peer_handler::PeerHandleError) -> CResult_boolPeerHandleErrorZ {
+       CResult_boolPeerHandleErrorZ {
+               contents: CResult_boolPeerHandleErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_FundingLockedDecodeErrorZ.
-pub extern "C" fn CResult_FundingLockedDecodeErrorZ_free(_res: CResult_FundingLockedDecodeErrorZ) { }
-impl Drop for CResult_FundingLockedDecodeErrorZ {
+/// Frees any resources used by the CResult_boolPeerHandleErrorZ.
+pub extern "C" fn CResult_boolPeerHandleErrorZ_free(_res: CResult_boolPeerHandleErrorZ) { }
+impl Drop for CResult_boolPeerHandleErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -6904,16 +7044,16 @@ impl Drop for CResult_FundingLockedDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::FundingLocked, crate::lightning::ln::msgs::DecodeError>> for CResult_FundingLockedDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::FundingLocked, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<bool, crate::lightning::ln::peer_handler::PeerHandleError>> for CResult_boolPeerHandleErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<bool, crate::lightning::ln::peer_handler::PeerHandleError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_FundingLockedDecodeErrorZPtr { result }
+                       CResult_boolPeerHandleErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_FundingLockedDecodeErrorZPtr { err }
+                       CResult_boolPeerHandleErrorZPtr { err }
                };
                Self {
                        contents,
@@ -6921,68 +7061,68 @@ impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::FundingLocked
                }
        }
 }
-impl Clone for CResult_FundingLockedDecodeErrorZ {
+impl Clone for CResult_boolPeerHandleErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_FundingLockedDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::FundingLocked>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_boolPeerHandleErrorZPtr {
+                               result: Box::into_raw(Box::new(<bool>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_FundingLockedDecodeErrorZPtr {
-                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
+                       Self { result_ok: false, contents: CResult_boolPeerHandleErrorZPtr {
+                               err: Box::into_raw(Box::new(<crate::lightning::ln::peer_handler::PeerHandleError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_FundingLockedDecodeErrorZ which has the same data as `orig`
+/// Creates a new CResult_boolPeerHandleErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_FundingLockedDecodeErrorZ_clone(orig: &CResult_FundingLockedDecodeErrorZ) -> CResult_FundingLockedDecodeErrorZ { orig.clone() }
+pub extern "C" fn CResult_boolPeerHandleErrorZ_clone(orig: &CResult_boolPeerHandleErrorZ) -> CResult_boolPeerHandleErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_InitDecodeErrorZ
-pub union CResult_InitDecodeErrorZPtr {
+/// The contents of CResult_DirectionalChannelInfoDecodeErrorZ
+pub union CResult_DirectionalChannelInfoDecodeErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::ln::msgs::Init,
+       pub result: *mut crate::lightning::routing::network_graph::DirectionalChannelInfo,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
        pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// 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_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`.
-pub struct CResult_InitDecodeErrorZ {
-       /// The contents of this CResult_InitDecodeErrorZ, accessible via either
+pub struct CResult_DirectionalChannelInfoDecodeErrorZ {
+       /// The contents of this CResult_DirectionalChannelInfoDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_InitDecodeErrorZPtr,
-       /// Whether this CResult_InitDecodeErrorZ represents a success state.
+       pub contents: CResult_DirectionalChannelInfoDecodeErrorZPtr,
+       /// Whether this CResult_DirectionalChannelInfoDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_InitDecodeErrorZ in the success state.
-pub extern "C" fn CResult_InitDecodeErrorZ_ok(o: crate::lightning::ln::msgs::Init) -> CResult_InitDecodeErrorZ {
-       CResult_InitDecodeErrorZ {
-               contents: CResult_InitDecodeErrorZPtr {
+/// Creates a new CResult_DirectionalChannelInfoDecodeErrorZ in the success state.
+pub extern "C" fn CResult_DirectionalChannelInfoDecodeErrorZ_ok(o: crate::lightning::routing::network_graph::DirectionalChannelInfo) -> CResult_DirectionalChannelInfoDecodeErrorZ {
+       CResult_DirectionalChannelInfoDecodeErrorZ {
+               contents: CResult_DirectionalChannelInfoDecodeErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_InitDecodeErrorZ in the error state.
-pub extern "C" fn CResult_InitDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_InitDecodeErrorZ {
-       CResult_InitDecodeErrorZ {
-               contents: CResult_InitDecodeErrorZPtr {
+/// Creates a new CResult_DirectionalChannelInfoDecodeErrorZ in the error state.
+pub extern "C" fn CResult_DirectionalChannelInfoDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_DirectionalChannelInfoDecodeErrorZ {
+       CResult_DirectionalChannelInfoDecodeErrorZ {
+               contents: CResult_DirectionalChannelInfoDecodeErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_InitDecodeErrorZ.
-pub extern "C" fn CResult_InitDecodeErrorZ_free(_res: CResult_InitDecodeErrorZ) { }
-impl Drop for CResult_InitDecodeErrorZ {
+/// Frees any resources used by the CResult_DirectionalChannelInfoDecodeErrorZ.
+pub extern "C" fn CResult_DirectionalChannelInfoDecodeErrorZ_free(_res: CResult_DirectionalChannelInfoDecodeErrorZ) { }
+impl Drop for CResult_DirectionalChannelInfoDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -6995,16 +7135,16 @@ impl Drop for CResult_InitDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::Init, crate::lightning::ln::msgs::DecodeError>> for CResult_InitDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::Init, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::routing::network_graph::DirectionalChannelInfo, crate::lightning::ln::msgs::DecodeError>> for CResult_DirectionalChannelInfoDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::routing::network_graph::DirectionalChannelInfo, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_InitDecodeErrorZPtr { result }
+                       CResult_DirectionalChannelInfoDecodeErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_InitDecodeErrorZPtr { err }
+                       CResult_DirectionalChannelInfoDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -7012,68 +7152,68 @@ impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::Init, crate::
                }
        }
 }
-impl Clone for CResult_InitDecodeErrorZ {
+impl Clone for CResult_DirectionalChannelInfoDecodeErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_InitDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::Init>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_DirectionalChannelInfoDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::routing::network_graph::DirectionalChannelInfo>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_InitDecodeErrorZPtr {
+                       Self { result_ok: false, contents: CResult_DirectionalChannelInfoDecodeErrorZPtr {
                                err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_InitDecodeErrorZ which has the same data as `orig`
+/// Creates a new CResult_DirectionalChannelInfoDecodeErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_InitDecodeErrorZ_clone(orig: &CResult_InitDecodeErrorZ) -> CResult_InitDecodeErrorZ { orig.clone() }
+pub extern "C" fn CResult_DirectionalChannelInfoDecodeErrorZ_clone(orig: &CResult_DirectionalChannelInfoDecodeErrorZ) -> CResult_DirectionalChannelInfoDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_OpenChannelDecodeErrorZ
-pub union CResult_OpenChannelDecodeErrorZPtr {
+/// The contents of CResult_ChannelInfoDecodeErrorZ
+pub union CResult_ChannelInfoDecodeErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::ln::msgs::OpenChannel,
+       pub result: *mut crate::lightning::routing::network_graph::ChannelInfo,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
        pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// 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_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`.
-pub struct CResult_OpenChannelDecodeErrorZ {
-       /// The contents of this CResult_OpenChannelDecodeErrorZ, accessible via either
+pub struct CResult_ChannelInfoDecodeErrorZ {
+       /// The contents of this CResult_ChannelInfoDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_OpenChannelDecodeErrorZPtr,
-       /// Whether this CResult_OpenChannelDecodeErrorZ represents a success state.
+       pub contents: CResult_ChannelInfoDecodeErrorZPtr,
+       /// Whether this CResult_ChannelInfoDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_OpenChannelDecodeErrorZ in the success state.
-pub extern "C" fn CResult_OpenChannelDecodeErrorZ_ok(o: crate::lightning::ln::msgs::OpenChannel) -> CResult_OpenChannelDecodeErrorZ {
-       CResult_OpenChannelDecodeErrorZ {
-               contents: CResult_OpenChannelDecodeErrorZPtr {
+/// Creates a new CResult_ChannelInfoDecodeErrorZ in the success state.
+pub extern "C" fn CResult_ChannelInfoDecodeErrorZ_ok(o: crate::lightning::routing::network_graph::ChannelInfo) -> CResult_ChannelInfoDecodeErrorZ {
+       CResult_ChannelInfoDecodeErrorZ {
+               contents: CResult_ChannelInfoDecodeErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_OpenChannelDecodeErrorZ in the error state.
-pub extern "C" fn CResult_OpenChannelDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_OpenChannelDecodeErrorZ {
-       CResult_OpenChannelDecodeErrorZ {
-               contents: CResult_OpenChannelDecodeErrorZPtr {
+/// Creates a new CResult_ChannelInfoDecodeErrorZ in the error state.
+pub extern "C" fn CResult_ChannelInfoDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_ChannelInfoDecodeErrorZ {
+       CResult_ChannelInfoDecodeErrorZ {
+               contents: CResult_ChannelInfoDecodeErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_OpenChannelDecodeErrorZ.
-pub extern "C" fn CResult_OpenChannelDecodeErrorZ_free(_res: CResult_OpenChannelDecodeErrorZ) { }
-impl Drop for CResult_OpenChannelDecodeErrorZ {
+/// Frees any resources used by the CResult_ChannelInfoDecodeErrorZ.
+pub extern "C" fn CResult_ChannelInfoDecodeErrorZ_free(_res: CResult_ChannelInfoDecodeErrorZ) { }
+impl Drop for CResult_ChannelInfoDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -7086,16 +7226,16 @@ impl Drop for CResult_OpenChannelDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::OpenChannel, crate::lightning::ln::msgs::DecodeError>> for CResult_OpenChannelDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::OpenChannel, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::routing::network_graph::ChannelInfo, crate::lightning::ln::msgs::DecodeError>> for CResult_ChannelInfoDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::routing::network_graph::ChannelInfo, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_OpenChannelDecodeErrorZPtr { result }
+                       CResult_ChannelInfoDecodeErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_OpenChannelDecodeErrorZPtr { err }
+                       CResult_ChannelInfoDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -7103,68 +7243,68 @@ impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::OpenChannel,
                }
        }
 }
-impl Clone for CResult_OpenChannelDecodeErrorZ {
+impl Clone for CResult_ChannelInfoDecodeErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_OpenChannelDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::OpenChannel>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_ChannelInfoDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::routing::network_graph::ChannelInfo>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_OpenChannelDecodeErrorZPtr {
+                       Self { result_ok: false, contents: CResult_ChannelInfoDecodeErrorZPtr {
                                err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_OpenChannelDecodeErrorZ which has the same data as `orig`
+/// Creates a new CResult_ChannelInfoDecodeErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_OpenChannelDecodeErrorZ_clone(orig: &CResult_OpenChannelDecodeErrorZ) -> CResult_OpenChannelDecodeErrorZ { orig.clone() }
+pub extern "C" fn CResult_ChannelInfoDecodeErrorZ_clone(orig: &CResult_ChannelInfoDecodeErrorZ) -> CResult_ChannelInfoDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_RevokeAndACKDecodeErrorZ
-pub union CResult_RevokeAndACKDecodeErrorZPtr {
+/// The contents of CResult_RoutingFeesDecodeErrorZ
+pub union CResult_RoutingFeesDecodeErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::ln::msgs::RevokeAndACK,
+       pub result: *mut crate::lightning::routing::network_graph::RoutingFees,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
        pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// 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_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`.
-pub struct CResult_RevokeAndACKDecodeErrorZ {
-       /// The contents of this CResult_RevokeAndACKDecodeErrorZ, accessible via either
+pub struct CResult_RoutingFeesDecodeErrorZ {
+       /// The contents of this CResult_RoutingFeesDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_RevokeAndACKDecodeErrorZPtr,
-       /// Whether this CResult_RevokeAndACKDecodeErrorZ represents a success state.
+       pub contents: CResult_RoutingFeesDecodeErrorZPtr,
+       /// Whether this CResult_RoutingFeesDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_RevokeAndACKDecodeErrorZ in the success state.
-pub extern "C" fn CResult_RevokeAndACKDecodeErrorZ_ok(o: crate::lightning::ln::msgs::RevokeAndACK) -> CResult_RevokeAndACKDecodeErrorZ {
-       CResult_RevokeAndACKDecodeErrorZ {
-               contents: CResult_RevokeAndACKDecodeErrorZPtr {
+/// Creates a new CResult_RoutingFeesDecodeErrorZ in the success state.
+pub extern "C" fn CResult_RoutingFeesDecodeErrorZ_ok(o: crate::lightning::routing::network_graph::RoutingFees) -> CResult_RoutingFeesDecodeErrorZ {
+       CResult_RoutingFeesDecodeErrorZ {
+               contents: CResult_RoutingFeesDecodeErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_RevokeAndACKDecodeErrorZ in the error state.
-pub extern "C" fn CResult_RevokeAndACKDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_RevokeAndACKDecodeErrorZ {
-       CResult_RevokeAndACKDecodeErrorZ {
-               contents: CResult_RevokeAndACKDecodeErrorZPtr {
+/// Creates a new CResult_RoutingFeesDecodeErrorZ in the error state.
+pub extern "C" fn CResult_RoutingFeesDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_RoutingFeesDecodeErrorZ {
+       CResult_RoutingFeesDecodeErrorZ {
+               contents: CResult_RoutingFeesDecodeErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_RevokeAndACKDecodeErrorZ.
-pub extern "C" fn CResult_RevokeAndACKDecodeErrorZ_free(_res: CResult_RevokeAndACKDecodeErrorZ) { }
-impl Drop for CResult_RevokeAndACKDecodeErrorZ {
+/// Frees any resources used by the CResult_RoutingFeesDecodeErrorZ.
+pub extern "C" fn CResult_RoutingFeesDecodeErrorZ_free(_res: CResult_RoutingFeesDecodeErrorZ) { }
+impl Drop for CResult_RoutingFeesDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -7177,16 +7317,16 @@ impl Drop for CResult_RevokeAndACKDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::RevokeAndACK, crate::lightning::ln::msgs::DecodeError>> for CResult_RevokeAndACKDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::RevokeAndACK, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::routing::network_graph::RoutingFees, crate::lightning::ln::msgs::DecodeError>> for CResult_RoutingFeesDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::routing::network_graph::RoutingFees, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_RevokeAndACKDecodeErrorZPtr { result }
+                       CResult_RoutingFeesDecodeErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_RevokeAndACKDecodeErrorZPtr { err }
+                       CResult_RoutingFeesDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -7194,68 +7334,68 @@ impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::RevokeAndACK,
                }
        }
 }
-impl Clone for CResult_RevokeAndACKDecodeErrorZ {
+impl Clone for CResult_RoutingFeesDecodeErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_RevokeAndACKDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::RevokeAndACK>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_RoutingFeesDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::routing::network_graph::RoutingFees>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_RevokeAndACKDecodeErrorZPtr {
+                       Self { result_ok: false, contents: CResult_RoutingFeesDecodeErrorZPtr {
                                err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_RevokeAndACKDecodeErrorZ which has the same data as `orig`
+/// Creates a new CResult_RoutingFeesDecodeErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_RevokeAndACKDecodeErrorZ_clone(orig: &CResult_RevokeAndACKDecodeErrorZ) -> CResult_RevokeAndACKDecodeErrorZ { orig.clone() }
+pub extern "C" fn CResult_RoutingFeesDecodeErrorZ_clone(orig: &CResult_RoutingFeesDecodeErrorZ) -> CResult_RoutingFeesDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_ShutdownDecodeErrorZ
-pub union CResult_ShutdownDecodeErrorZPtr {
+/// The contents of CResult_NodeAnnouncementInfoDecodeErrorZ
+pub union CResult_NodeAnnouncementInfoDecodeErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::ln::msgs::Shutdown,
+       pub result: *mut crate::lightning::routing::network_graph::NodeAnnouncementInfo,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
        pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// 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_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`.
-pub struct CResult_ShutdownDecodeErrorZ {
-       /// The contents of this CResult_ShutdownDecodeErrorZ, accessible via either
+pub struct CResult_NodeAnnouncementInfoDecodeErrorZ {
+       /// The contents of this CResult_NodeAnnouncementInfoDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_ShutdownDecodeErrorZPtr,
-       /// Whether this CResult_ShutdownDecodeErrorZ represents a success state.
+       pub contents: CResult_NodeAnnouncementInfoDecodeErrorZPtr,
+       /// Whether this CResult_NodeAnnouncementInfoDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_ShutdownDecodeErrorZ in the success state.
-pub extern "C" fn CResult_ShutdownDecodeErrorZ_ok(o: crate::lightning::ln::msgs::Shutdown) -> CResult_ShutdownDecodeErrorZ {
-       CResult_ShutdownDecodeErrorZ {
-               contents: CResult_ShutdownDecodeErrorZPtr {
+/// Creates a new CResult_NodeAnnouncementInfoDecodeErrorZ in the success state.
+pub extern "C" fn CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o: crate::lightning::routing::network_graph::NodeAnnouncementInfo) -> CResult_NodeAnnouncementInfoDecodeErrorZ {
+       CResult_NodeAnnouncementInfoDecodeErrorZ {
+               contents: CResult_NodeAnnouncementInfoDecodeErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_ShutdownDecodeErrorZ in the error state.
-pub extern "C" fn CResult_ShutdownDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_ShutdownDecodeErrorZ {
-       CResult_ShutdownDecodeErrorZ {
-               contents: CResult_ShutdownDecodeErrorZPtr {
+/// Creates a new CResult_NodeAnnouncementInfoDecodeErrorZ in the error state.
+pub extern "C" fn CResult_NodeAnnouncementInfoDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_NodeAnnouncementInfoDecodeErrorZ {
+       CResult_NodeAnnouncementInfoDecodeErrorZ {
+               contents: CResult_NodeAnnouncementInfoDecodeErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_ShutdownDecodeErrorZ.
-pub extern "C" fn CResult_ShutdownDecodeErrorZ_free(_res: CResult_ShutdownDecodeErrorZ) { }
-impl Drop for CResult_ShutdownDecodeErrorZ {
+/// Frees any resources used by the CResult_NodeAnnouncementInfoDecodeErrorZ.
+pub extern "C" fn CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res: CResult_NodeAnnouncementInfoDecodeErrorZ) { }
+impl Drop for CResult_NodeAnnouncementInfoDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -7268,16 +7408,16 @@ impl Drop for CResult_ShutdownDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::Shutdown, crate::lightning::ln::msgs::DecodeError>> for CResult_ShutdownDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::Shutdown, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::routing::network_graph::NodeAnnouncementInfo, crate::lightning::ln::msgs::DecodeError>> for CResult_NodeAnnouncementInfoDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::routing::network_graph::NodeAnnouncementInfo, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_ShutdownDecodeErrorZPtr { result }
+                       CResult_NodeAnnouncementInfoDecodeErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_ShutdownDecodeErrorZPtr { err }
+                       CResult_NodeAnnouncementInfoDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -7285,68 +7425,114 @@ impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::Shutdown, cra
                }
        }
 }
-impl Clone for CResult_ShutdownDecodeErrorZ {
+impl Clone for CResult_NodeAnnouncementInfoDecodeErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_ShutdownDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::Shutdown>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_NodeAnnouncementInfoDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::routing::network_graph::NodeAnnouncementInfo>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_ShutdownDecodeErrorZPtr {
+                       Self { result_ok: false, contents: CResult_NodeAnnouncementInfoDecodeErrorZPtr {
                                err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_ShutdownDecodeErrorZ which has the same data as `orig`
+/// Creates a new CResult_NodeAnnouncementInfoDecodeErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_ShutdownDecodeErrorZ_clone(orig: &CResult_ShutdownDecodeErrorZ) -> CResult_ShutdownDecodeErrorZ { orig.clone() }
+pub extern "C" fn CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig: &CResult_NodeAnnouncementInfoDecodeErrorZ) -> CResult_NodeAnnouncementInfoDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_UpdateFailHTLCDecodeErrorZ
-pub union CResult_UpdateFailHTLCDecodeErrorZPtr {
+/// A dynamically-allocated array of u64s of arbitrary size.
+/// This corresponds to std::vector in C++
+pub struct CVec_u64Z {
+       /// The elements in the array.
+       /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+       pub data: *mut u64,
+       /// The number of elements pointed to by `data`.
+       pub datalen: usize
+}
+impl CVec_u64Z {
+       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<u64> {
+               if self.datalen == 0 { return Vec::new(); }
+               let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
+               self.data = std::ptr::null_mut();
+               self.datalen = 0;
+               ret
+       }
+       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[u64] {
+               unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
+       }
+}
+impl From<Vec<u64>> for CVec_u64Z {
+       fn from(v: Vec<u64>) -> Self {
+               let datalen = v.len();
+               let data = Box::into_raw(v.into_boxed_slice());
+               Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
+       }
+}
+#[no_mangle]
+/// Frees the buffer pointed to by `data` if `datalen` is non-0.
+pub extern "C" fn CVec_u64Z_free(_res: CVec_u64Z) { }
+impl Drop for CVec_u64Z {
+       fn drop(&mut self) {
+               if self.datalen == 0 { return; }
+               unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
+       }
+}
+impl Clone for CVec_u64Z {
+       fn clone(&self) -> Self {
+               let mut res = Vec::new();
+               if self.datalen == 0 { return Self::from(res); }
+               res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
+               Self::from(res)
+       }
+}
+#[repr(C)]
+/// The contents of CResult_NodeInfoDecodeErrorZ
+pub union CResult_NodeInfoDecodeErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::ln::msgs::UpdateFailHTLC,
+       pub result: *mut crate::lightning::routing::network_graph::NodeInfo,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
        pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// 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.
+/// 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`.
-pub struct CResult_UpdateFailHTLCDecodeErrorZ {
-       /// The contents of this CResult_UpdateFailHTLCDecodeErrorZ, accessible via either
+pub struct CResult_NodeInfoDecodeErrorZ {
+       /// The contents of this CResult_NodeInfoDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_UpdateFailHTLCDecodeErrorZPtr,
-       /// Whether this CResult_UpdateFailHTLCDecodeErrorZ represents a success state.
+       pub contents: CResult_NodeInfoDecodeErrorZPtr,
+       /// Whether this CResult_NodeInfoDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_UpdateFailHTLCDecodeErrorZ in the success state.
-pub extern "C" fn CResult_UpdateFailHTLCDecodeErrorZ_ok(o: crate::lightning::ln::msgs::UpdateFailHTLC) -> CResult_UpdateFailHTLCDecodeErrorZ {
-       CResult_UpdateFailHTLCDecodeErrorZ {
-               contents: CResult_UpdateFailHTLCDecodeErrorZPtr {
+/// Creates a new CResult_NodeInfoDecodeErrorZ in the success state.
+pub extern "C" fn CResult_NodeInfoDecodeErrorZ_ok(o: crate::lightning::routing::network_graph::NodeInfo) -> CResult_NodeInfoDecodeErrorZ {
+       CResult_NodeInfoDecodeErrorZ {
+               contents: CResult_NodeInfoDecodeErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_UpdateFailHTLCDecodeErrorZ in the error state.
-pub extern "C" fn CResult_UpdateFailHTLCDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_UpdateFailHTLCDecodeErrorZ {
-       CResult_UpdateFailHTLCDecodeErrorZ {
-               contents: CResult_UpdateFailHTLCDecodeErrorZPtr {
+/// Creates a new CResult_NodeInfoDecodeErrorZ in the error state.
+pub extern "C" fn CResult_NodeInfoDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_NodeInfoDecodeErrorZ {
+       CResult_NodeInfoDecodeErrorZ {
+               contents: CResult_NodeInfoDecodeErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_UpdateFailHTLCDecodeErrorZ.
-pub extern "C" fn CResult_UpdateFailHTLCDecodeErrorZ_free(_res: CResult_UpdateFailHTLCDecodeErrorZ) { }
-impl Drop for CResult_UpdateFailHTLCDecodeErrorZ {
+/// Frees any resources used by the CResult_NodeInfoDecodeErrorZ.
+pub extern "C" fn CResult_NodeInfoDecodeErrorZ_free(_res: CResult_NodeInfoDecodeErrorZ) { }
+impl Drop for CResult_NodeInfoDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -7359,16 +7545,16 @@ impl Drop for CResult_UpdateFailHTLCDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::UpdateFailHTLC, crate::lightning::ln::msgs::DecodeError>> for CResult_UpdateFailHTLCDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::UpdateFailHTLC, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::routing::network_graph::NodeInfo, crate::lightning::ln::msgs::DecodeError>> for CResult_NodeInfoDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::routing::network_graph::NodeInfo, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_UpdateFailHTLCDecodeErrorZPtr { result }
+                       CResult_NodeInfoDecodeErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_UpdateFailHTLCDecodeErrorZPtr { err }
+                       CResult_NodeInfoDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -7376,68 +7562,68 @@ impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::UpdateFailHTL
                }
        }
 }
-impl Clone for CResult_UpdateFailHTLCDecodeErrorZ {
+impl Clone for CResult_NodeInfoDecodeErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_UpdateFailHTLCDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::UpdateFailHTLC>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_NodeInfoDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::routing::network_graph::NodeInfo>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_UpdateFailHTLCDecodeErrorZPtr {
+                       Self { result_ok: false, contents: CResult_NodeInfoDecodeErrorZPtr {
                                err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_UpdateFailHTLCDecodeErrorZ which has the same data as `orig`
+/// Creates a new CResult_NodeInfoDecodeErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_UpdateFailHTLCDecodeErrorZ_clone(orig: &CResult_UpdateFailHTLCDecodeErrorZ) -> CResult_UpdateFailHTLCDecodeErrorZ { orig.clone() }
+pub extern "C" fn CResult_NodeInfoDecodeErrorZ_clone(orig: &CResult_NodeInfoDecodeErrorZ) -> CResult_NodeInfoDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_UpdateFailMalformedHTLCDecodeErrorZ
-pub union CResult_UpdateFailMalformedHTLCDecodeErrorZPtr {
+/// The contents of CResult_NetworkGraphDecodeErrorZ
+pub union CResult_NetworkGraphDecodeErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::ln::msgs::UpdateFailMalformedHTLC,
+       pub result: *mut crate::lightning::routing::network_graph::NetworkGraph,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
        pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// 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.
+/// 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`.
-pub struct CResult_UpdateFailMalformedHTLCDecodeErrorZ {
-       /// The contents of this CResult_UpdateFailMalformedHTLCDecodeErrorZ, accessible via either
+pub struct CResult_NetworkGraphDecodeErrorZ {
+       /// The contents of this CResult_NetworkGraphDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_UpdateFailMalformedHTLCDecodeErrorZPtr,
-       /// Whether this CResult_UpdateFailMalformedHTLCDecodeErrorZ represents a success state.
+       pub contents: CResult_NetworkGraphDecodeErrorZPtr,
+       /// Whether this CResult_NetworkGraphDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_UpdateFailMalformedHTLCDecodeErrorZ in the success state.
-pub extern "C" fn CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o: crate::lightning::ln::msgs::UpdateFailMalformedHTLC) -> CResult_UpdateFailMalformedHTLCDecodeErrorZ {
-       CResult_UpdateFailMalformedHTLCDecodeErrorZ {
-               contents: CResult_UpdateFailMalformedHTLCDecodeErrorZPtr {
+/// Creates a new CResult_NetworkGraphDecodeErrorZ in the success state.
+pub extern "C" fn CResult_NetworkGraphDecodeErrorZ_ok(o: crate::lightning::routing::network_graph::NetworkGraph) -> CResult_NetworkGraphDecodeErrorZ {
+       CResult_NetworkGraphDecodeErrorZ {
+               contents: CResult_NetworkGraphDecodeErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_UpdateFailMalformedHTLCDecodeErrorZ in the error state.
-pub extern "C" fn CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_UpdateFailMalformedHTLCDecodeErrorZ {
-       CResult_UpdateFailMalformedHTLCDecodeErrorZ {
-               contents: CResult_UpdateFailMalformedHTLCDecodeErrorZPtr {
+/// Creates a new CResult_NetworkGraphDecodeErrorZ in the error state.
+pub extern "C" fn CResult_NetworkGraphDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_NetworkGraphDecodeErrorZ {
+       CResult_NetworkGraphDecodeErrorZ {
+               contents: CResult_NetworkGraphDecodeErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_UpdateFailMalformedHTLCDecodeErrorZ.
-pub extern "C" fn CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res: CResult_UpdateFailMalformedHTLCDecodeErrorZ) { }
-impl Drop for CResult_UpdateFailMalformedHTLCDecodeErrorZ {
+/// Frees any resources used by the CResult_NetworkGraphDecodeErrorZ.
+pub extern "C" fn CResult_NetworkGraphDecodeErrorZ_free(_res: CResult_NetworkGraphDecodeErrorZ) { }
+impl Drop for CResult_NetworkGraphDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -7450,16 +7636,16 @@ impl Drop for CResult_UpdateFailMalformedHTLCDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::UpdateFailMalformedHTLC, crate::lightning::ln::msgs::DecodeError>> for CResult_UpdateFailMalformedHTLCDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::UpdateFailMalformedHTLC, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::routing::network_graph::NetworkGraph, crate::lightning::ln::msgs::DecodeError>> for CResult_NetworkGraphDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::routing::network_graph::NetworkGraph, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_UpdateFailMalformedHTLCDecodeErrorZPtr { result }
+                       CResult_NetworkGraphDecodeErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_UpdateFailMalformedHTLCDecodeErrorZPtr { err }
+                       CResult_NetworkGraphDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -7467,68 +7653,68 @@ impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::UpdateFailMal
                }
        }
 }
-impl Clone for CResult_UpdateFailMalformedHTLCDecodeErrorZ {
+impl Clone for CResult_NetworkGraphDecodeErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_UpdateFailMalformedHTLCDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::UpdateFailMalformedHTLC>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_NetworkGraphDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::routing::network_graph::NetworkGraph>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_UpdateFailMalformedHTLCDecodeErrorZPtr {
+                       Self { result_ok: false, contents: CResult_NetworkGraphDecodeErrorZPtr {
                                err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_UpdateFailMalformedHTLCDecodeErrorZ which has the same data as `orig`
+/// Creates a new CResult_NetworkGraphDecodeErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig: &CResult_UpdateFailMalformedHTLCDecodeErrorZ) -> CResult_UpdateFailMalformedHTLCDecodeErrorZ { orig.clone() }
+pub extern "C" fn CResult_NetworkGraphDecodeErrorZ_clone(orig: &CResult_NetworkGraphDecodeErrorZ) -> CResult_NetworkGraphDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_UpdateFeeDecodeErrorZ
-pub union CResult_UpdateFeeDecodeErrorZPtr {
+/// The contents of CResult_NetAddressu8Z
+pub union CResult_NetAddressu8ZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::ln::msgs::UpdateFee,
+       pub result: *mut crate::lightning::ln::msgs::NetAddress,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::lightning::ln::msgs::DecodeError,
+       pub err: *mut u8,
 }
 #[repr(C)]
-/// 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.
+/// 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`.
-pub struct CResult_UpdateFeeDecodeErrorZ {
-       /// The contents of this CResult_UpdateFeeDecodeErrorZ, accessible via either
+pub struct CResult_NetAddressu8Z {
+       /// The contents of this CResult_NetAddressu8Z, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_UpdateFeeDecodeErrorZPtr,
-       /// Whether this CResult_UpdateFeeDecodeErrorZ represents a success state.
+       pub contents: CResult_NetAddressu8ZPtr,
+       /// Whether this CResult_NetAddressu8Z represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_UpdateFeeDecodeErrorZ in the success state.
-pub extern "C" fn CResult_UpdateFeeDecodeErrorZ_ok(o: crate::lightning::ln::msgs::UpdateFee) -> CResult_UpdateFeeDecodeErrorZ {
-       CResult_UpdateFeeDecodeErrorZ {
-               contents: CResult_UpdateFeeDecodeErrorZPtr {
+/// Creates a new CResult_NetAddressu8Z in the success state.
+pub extern "C" fn CResult_NetAddressu8Z_ok(o: crate::lightning::ln::msgs::NetAddress) -> CResult_NetAddressu8Z {
+       CResult_NetAddressu8Z {
+               contents: CResult_NetAddressu8ZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_UpdateFeeDecodeErrorZ in the error state.
-pub extern "C" fn CResult_UpdateFeeDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_UpdateFeeDecodeErrorZ {
-       CResult_UpdateFeeDecodeErrorZ {
-               contents: CResult_UpdateFeeDecodeErrorZPtr {
+/// Creates a new CResult_NetAddressu8Z in the error state.
+pub extern "C" fn CResult_NetAddressu8Z_err(e: u8) -> CResult_NetAddressu8Z {
+       CResult_NetAddressu8Z {
+               contents: CResult_NetAddressu8ZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_UpdateFeeDecodeErrorZ.
-pub extern "C" fn CResult_UpdateFeeDecodeErrorZ_free(_res: CResult_UpdateFeeDecodeErrorZ) { }
-impl Drop for CResult_UpdateFeeDecodeErrorZ {
+/// Frees any resources used by the CResult_NetAddressu8Z.
+pub extern "C" fn CResult_NetAddressu8Z_free(_res: CResult_NetAddressu8Z) { }
+impl Drop for CResult_NetAddressu8Z {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -7541,16 +7727,16 @@ impl Drop for CResult_UpdateFeeDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::UpdateFee, crate::lightning::ln::msgs::DecodeError>> for CResult_UpdateFeeDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::UpdateFee, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::NetAddress, u8>> for CResult_NetAddressu8Z {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::NetAddress, u8>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_UpdateFeeDecodeErrorZPtr { result }
+                       CResult_NetAddressu8ZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_UpdateFeeDecodeErrorZPtr { err }
+                       CResult_NetAddressu8ZPtr { err }
                };
                Self {
                        contents,
@@ -7558,68 +7744,68 @@ impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::UpdateFee, cr
                }
        }
 }
-impl Clone for CResult_UpdateFeeDecodeErrorZ {
+impl Clone for CResult_NetAddressu8Z {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_UpdateFeeDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::UpdateFee>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_NetAddressu8ZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::NetAddress>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_UpdateFeeDecodeErrorZPtr {
-                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
+                       Self { result_ok: false, contents: CResult_NetAddressu8ZPtr {
+                               err: Box::into_raw(Box::new(<u8>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_UpdateFeeDecodeErrorZ which has the same data as `orig`
+/// Creates a new CResult_NetAddressu8Z which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_UpdateFeeDecodeErrorZ_clone(orig: &CResult_UpdateFeeDecodeErrorZ) -> CResult_UpdateFeeDecodeErrorZ { orig.clone() }
+pub extern "C" fn CResult_NetAddressu8Z_clone(orig: &CResult_NetAddressu8Z) -> CResult_NetAddressu8Z { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_UpdateFulfillHTLCDecodeErrorZ
-pub union CResult_UpdateFulfillHTLCDecodeErrorZPtr {
+/// The contents of CResult_CResult_NetAddressu8ZDecodeErrorZ
+pub union CResult_CResult_NetAddressu8ZDecodeErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::ln::msgs::UpdateFulfillHTLC,
+       pub result: *mut crate::c_types::derived::CResult_NetAddressu8Z,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
        pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// 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_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`.
-pub struct CResult_UpdateFulfillHTLCDecodeErrorZ {
-       /// The contents of this CResult_UpdateFulfillHTLCDecodeErrorZ, accessible via either
+pub struct CResult_CResult_NetAddressu8ZDecodeErrorZ {
+       /// The contents of this CResult_CResult_NetAddressu8ZDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_UpdateFulfillHTLCDecodeErrorZPtr,
-       /// Whether this CResult_UpdateFulfillHTLCDecodeErrorZ represents a success state.
+       pub contents: CResult_CResult_NetAddressu8ZDecodeErrorZPtr,
+       /// Whether this CResult_CResult_NetAddressu8ZDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_UpdateFulfillHTLCDecodeErrorZ in the success state.
-pub extern "C" fn CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o: crate::lightning::ln::msgs::UpdateFulfillHTLC) -> CResult_UpdateFulfillHTLCDecodeErrorZ {
-       CResult_UpdateFulfillHTLCDecodeErrorZ {
-               contents: CResult_UpdateFulfillHTLCDecodeErrorZPtr {
+/// Creates a new CResult_CResult_NetAddressu8ZDecodeErrorZ in the success state.
+pub extern "C" fn CResult_CResult_NetAddressu8ZDecodeErrorZ_ok(o: crate::c_types::derived::CResult_NetAddressu8Z) -> CResult_CResult_NetAddressu8ZDecodeErrorZ {
+       CResult_CResult_NetAddressu8ZDecodeErrorZ {
+               contents: CResult_CResult_NetAddressu8ZDecodeErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_UpdateFulfillHTLCDecodeErrorZ in the error state.
-pub extern "C" fn CResult_UpdateFulfillHTLCDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_UpdateFulfillHTLCDecodeErrorZ {
-       CResult_UpdateFulfillHTLCDecodeErrorZ {
-               contents: CResult_UpdateFulfillHTLCDecodeErrorZPtr {
+/// Creates a new CResult_CResult_NetAddressu8ZDecodeErrorZ in the error state.
+pub extern "C" fn CResult_CResult_NetAddressu8ZDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_CResult_NetAddressu8ZDecodeErrorZ {
+       CResult_CResult_NetAddressu8ZDecodeErrorZ {
+               contents: CResult_CResult_NetAddressu8ZDecodeErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_UpdateFulfillHTLCDecodeErrorZ.
-pub extern "C" fn CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res: CResult_UpdateFulfillHTLCDecodeErrorZ) { }
-impl Drop for CResult_UpdateFulfillHTLCDecodeErrorZ {
+/// Frees any resources used by the CResult_CResult_NetAddressu8ZDecodeErrorZ.
+pub extern "C" fn CResult_CResult_NetAddressu8ZDecodeErrorZ_free(_res: CResult_CResult_NetAddressu8ZDecodeErrorZ) { }
+impl Drop for CResult_CResult_NetAddressu8ZDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -7632,16 +7818,16 @@ impl Drop for CResult_UpdateFulfillHTLCDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::UpdateFulfillHTLC, crate::lightning::ln::msgs::DecodeError>> for CResult_UpdateFulfillHTLCDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::UpdateFulfillHTLC, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::c_types::derived::CResult_NetAddressu8Z, crate::lightning::ln::msgs::DecodeError>> for CResult_CResult_NetAddressu8ZDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::c_types::derived::CResult_NetAddressu8Z, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_UpdateFulfillHTLCDecodeErrorZPtr { result }
+                       CResult_CResult_NetAddressu8ZDecodeErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_UpdateFulfillHTLCDecodeErrorZPtr { err }
+                       CResult_CResult_NetAddressu8ZDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -7649,68 +7835,68 @@ impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::UpdateFulfill
                }
        }
 }
-impl Clone for CResult_UpdateFulfillHTLCDecodeErrorZ {
+impl Clone for CResult_CResult_NetAddressu8ZDecodeErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_UpdateFulfillHTLCDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::UpdateFulfillHTLC>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_CResult_NetAddressu8ZDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::c_types::derived::CResult_NetAddressu8Z>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_UpdateFulfillHTLCDecodeErrorZPtr {
+                       Self { result_ok: false, contents: CResult_CResult_NetAddressu8ZDecodeErrorZPtr {
                                err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_UpdateFulfillHTLCDecodeErrorZ which has the same data as `orig`
+/// Creates a new CResult_CResult_NetAddressu8ZDecodeErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig: &CResult_UpdateFulfillHTLCDecodeErrorZ) -> CResult_UpdateFulfillHTLCDecodeErrorZ { orig.clone() }
+pub extern "C" fn CResult_CResult_NetAddressu8ZDecodeErrorZ_clone(orig: &CResult_CResult_NetAddressu8ZDecodeErrorZ) -> CResult_CResult_NetAddressu8ZDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_UpdateAddHTLCDecodeErrorZ
-pub union CResult_UpdateAddHTLCDecodeErrorZPtr {
+/// The contents of CResult_NetAddressDecodeErrorZ
+pub union CResult_NetAddressDecodeErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::ln::msgs::UpdateAddHTLC,
+       pub result: *mut crate::lightning::ln::msgs::NetAddress,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
        pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// 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_NetAddressDecodeErrorZ represents the result of a fallible operation,
+/// containing a crate::lightning::ln::msgs::NetAddress on success and a crate::lightning::ln::msgs::DecodeError on failure.
 /// `result_ok` indicates the overall state, and the contents are provided via `contents`.
-pub struct CResult_UpdateAddHTLCDecodeErrorZ {
-       /// The contents of this CResult_UpdateAddHTLCDecodeErrorZ, accessible via either
+pub struct CResult_NetAddressDecodeErrorZ {
+       /// The contents of this CResult_NetAddressDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_UpdateAddHTLCDecodeErrorZPtr,
-       /// Whether this CResult_UpdateAddHTLCDecodeErrorZ represents a success state.
+       pub contents: CResult_NetAddressDecodeErrorZPtr,
+       /// Whether this CResult_NetAddressDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_UpdateAddHTLCDecodeErrorZ in the success state.
-pub extern "C" fn CResult_UpdateAddHTLCDecodeErrorZ_ok(o: crate::lightning::ln::msgs::UpdateAddHTLC) -> CResult_UpdateAddHTLCDecodeErrorZ {
-       CResult_UpdateAddHTLCDecodeErrorZ {
-               contents: CResult_UpdateAddHTLCDecodeErrorZPtr {
+/// Creates a new CResult_NetAddressDecodeErrorZ in the success state.
+pub extern "C" fn CResult_NetAddressDecodeErrorZ_ok(o: crate::lightning::ln::msgs::NetAddress) -> CResult_NetAddressDecodeErrorZ {
+       CResult_NetAddressDecodeErrorZ {
+               contents: CResult_NetAddressDecodeErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_UpdateAddHTLCDecodeErrorZ in the error state.
-pub extern "C" fn CResult_UpdateAddHTLCDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_UpdateAddHTLCDecodeErrorZ {
-       CResult_UpdateAddHTLCDecodeErrorZ {
-               contents: CResult_UpdateAddHTLCDecodeErrorZPtr {
+/// Creates a new CResult_NetAddressDecodeErrorZ in the error state.
+pub extern "C" fn CResult_NetAddressDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_NetAddressDecodeErrorZ {
+       CResult_NetAddressDecodeErrorZ {
+               contents: CResult_NetAddressDecodeErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_UpdateAddHTLCDecodeErrorZ.
-pub extern "C" fn CResult_UpdateAddHTLCDecodeErrorZ_free(_res: CResult_UpdateAddHTLCDecodeErrorZ) { }
-impl Drop for CResult_UpdateAddHTLCDecodeErrorZ {
+/// Frees any resources used by the CResult_NetAddressDecodeErrorZ.
+pub extern "C" fn CResult_NetAddressDecodeErrorZ_free(_res: CResult_NetAddressDecodeErrorZ) { }
+impl Drop for CResult_NetAddressDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -7723,16 +7909,16 @@ impl Drop for CResult_UpdateAddHTLCDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::UpdateAddHTLC, crate::lightning::ln::msgs::DecodeError>> for CResult_UpdateAddHTLCDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::UpdateAddHTLC, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::NetAddress, crate::lightning::ln::msgs::DecodeError>> for CResult_NetAddressDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::NetAddress, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_UpdateAddHTLCDecodeErrorZPtr { result }
+                       CResult_NetAddressDecodeErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_UpdateAddHTLCDecodeErrorZPtr { err }
+                       CResult_NetAddressDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -7740,159 +7926,252 @@ impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::UpdateAddHTLC
                }
        }
 }
-impl Clone for CResult_UpdateAddHTLCDecodeErrorZ {
+impl Clone for CResult_NetAddressDecodeErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_UpdateAddHTLCDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::UpdateAddHTLC>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_NetAddressDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::NetAddress>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_UpdateAddHTLCDecodeErrorZPtr {
+                       Self { result_ok: false, contents: CResult_NetAddressDecodeErrorZPtr {
                                err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_UpdateAddHTLCDecodeErrorZ which has the same data as `orig`
+/// Creates a new CResult_NetAddressDecodeErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_UpdateAddHTLCDecodeErrorZ_clone(orig: &CResult_UpdateAddHTLCDecodeErrorZ) -> CResult_UpdateAddHTLCDecodeErrorZ { orig.clone() }
+pub extern "C" fn CResult_NetAddressDecodeErrorZ_clone(orig: &CResult_NetAddressDecodeErrorZ) -> CResult_NetAddressDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_PingDecodeErrorZ
-pub union CResult_PingDecodeErrorZPtr {
-       /// A pointer to the contents in the success state.
-       /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::ln::msgs::Ping,
-       /// A pointer to the contents in the error state.
-       /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::lightning::ln::msgs::DecodeError,
+/// A dynamically-allocated array of crate::lightning::ln::msgs::UpdateAddHTLCs of arbitrary size.
+/// This corresponds to std::vector in C++
+pub struct CVec_UpdateAddHTLCZ {
+       /// The elements in the array.
+       /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+       pub data: *mut crate::lightning::ln::msgs::UpdateAddHTLC,
+       /// The number of elements pointed to by `data`.
+       pub datalen: usize
+}
+impl CVec_UpdateAddHTLCZ {
+       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::lightning::ln::msgs::UpdateAddHTLC> {
+               if self.datalen == 0 { return Vec::new(); }
+               let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
+               self.data = std::ptr::null_mut();
+               self.datalen = 0;
+               ret
+       }
+       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::lightning::ln::msgs::UpdateAddHTLC] {
+               unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
+       }
+}
+impl From<Vec<crate::lightning::ln::msgs::UpdateAddHTLC>> for CVec_UpdateAddHTLCZ {
+       fn from(v: Vec<crate::lightning::ln::msgs::UpdateAddHTLC>) -> Self {
+               let datalen = v.len();
+               let data = Box::into_raw(v.into_boxed_slice());
+               Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
+       }
+}
+#[no_mangle]
+/// Frees the buffer pointed to by `data` if `datalen` is non-0.
+pub extern "C" fn CVec_UpdateAddHTLCZ_free(_res: CVec_UpdateAddHTLCZ) { }
+impl Drop for CVec_UpdateAddHTLCZ {
+       fn drop(&mut self) {
+               if self.datalen == 0 { return; }
+               unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
+       }
+}
+impl Clone for CVec_UpdateAddHTLCZ {
+       fn clone(&self) -> Self {
+               let mut res = Vec::new();
+               if self.datalen == 0 { return Self::from(res); }
+               res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
+               Self::from(res)
+       }
+}
+#[repr(C)]
+/// A dynamically-allocated array of crate::lightning::ln::msgs::UpdateFulfillHTLCs of arbitrary size.
+/// This corresponds to std::vector in C++
+pub struct CVec_UpdateFulfillHTLCZ {
+       /// The elements in the array.
+       /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+       pub data: *mut crate::lightning::ln::msgs::UpdateFulfillHTLC,
+       /// The number of elements pointed to by `data`.
+       pub datalen: usize
+}
+impl CVec_UpdateFulfillHTLCZ {
+       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::lightning::ln::msgs::UpdateFulfillHTLC> {
+               if self.datalen == 0 { return Vec::new(); }
+               let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
+               self.data = std::ptr::null_mut();
+               self.datalen = 0;
+               ret
+       }
+       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::lightning::ln::msgs::UpdateFulfillHTLC] {
+               unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
+       }
+}
+impl From<Vec<crate::lightning::ln::msgs::UpdateFulfillHTLC>> for CVec_UpdateFulfillHTLCZ {
+       fn from(v: Vec<crate::lightning::ln::msgs::UpdateFulfillHTLC>) -> Self {
+               let datalen = v.len();
+               let data = Box::into_raw(v.into_boxed_slice());
+               Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
+       }
+}
+#[no_mangle]
+/// Frees the buffer pointed to by `data` if `datalen` is non-0.
+pub extern "C" fn CVec_UpdateFulfillHTLCZ_free(_res: CVec_UpdateFulfillHTLCZ) { }
+impl Drop for CVec_UpdateFulfillHTLCZ {
+       fn drop(&mut self) {
+               if self.datalen == 0 { return; }
+               unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
+       }
+}
+impl Clone for CVec_UpdateFulfillHTLCZ {
+       fn clone(&self) -> Self {
+               let mut res = Vec::new();
+               if self.datalen == 0 { return Self::from(res); }
+               res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
+               Self::from(res)
+       }
+}
+#[repr(C)]
+/// A dynamically-allocated array of crate::lightning::ln::msgs::UpdateFailHTLCs of arbitrary size.
+/// This corresponds to std::vector in C++
+pub struct CVec_UpdateFailHTLCZ {
+       /// The elements in the array.
+       /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+       pub data: *mut crate::lightning::ln::msgs::UpdateFailHTLC,
+       /// The number of elements pointed to by `data`.
+       pub datalen: usize
+}
+impl CVec_UpdateFailHTLCZ {
+       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::lightning::ln::msgs::UpdateFailHTLC> {
+               if self.datalen == 0 { return Vec::new(); }
+               let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
+               self.data = std::ptr::null_mut();
+               self.datalen = 0;
+               ret
+       }
+       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::lightning::ln::msgs::UpdateFailHTLC] {
+               unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
+       }
+}
+impl From<Vec<crate::lightning::ln::msgs::UpdateFailHTLC>> for CVec_UpdateFailHTLCZ {
+       fn from(v: Vec<crate::lightning::ln::msgs::UpdateFailHTLC>) -> Self {
+               let datalen = v.len();
+               let data = Box::into_raw(v.into_boxed_slice());
+               Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
+       }
+}
+#[no_mangle]
+/// Frees the buffer pointed to by `data` if `datalen` is non-0.
+pub extern "C" fn CVec_UpdateFailHTLCZ_free(_res: CVec_UpdateFailHTLCZ) { }
+impl Drop for CVec_UpdateFailHTLCZ {
+       fn drop(&mut self) {
+               if self.datalen == 0 { return; }
+               unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
+       }
+}
+impl Clone for CVec_UpdateFailHTLCZ {
+       fn clone(&self) -> Self {
+               let mut res = Vec::new();
+               if self.datalen == 0 { return Self::from(res); }
+               res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
+               Self::from(res)
+       }
 }
 #[repr(C)]
-/// 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`.
-pub struct CResult_PingDecodeErrorZ {
-       /// The contents of this CResult_PingDecodeErrorZ, accessible via either
-       /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_PingDecodeErrorZPtr,
-       /// Whether this CResult_PingDecodeErrorZ represents a success state.
-       pub result_ok: bool,
+/// A dynamically-allocated array of crate::lightning::ln::msgs::UpdateFailMalformedHTLCs of arbitrary size.
+/// This corresponds to std::vector in C++
+pub struct CVec_UpdateFailMalformedHTLCZ {
+       /// The elements in the array.
+       /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+       pub data: *mut crate::lightning::ln::msgs::UpdateFailMalformedHTLC,
+       /// The number of elements pointed to by `data`.
+       pub datalen: usize
 }
-#[no_mangle]
-/// Creates a new CResult_PingDecodeErrorZ in the success state.
-pub extern "C" fn CResult_PingDecodeErrorZ_ok(o: crate::lightning::ln::msgs::Ping) -> CResult_PingDecodeErrorZ {
-       CResult_PingDecodeErrorZ {
-               contents: CResult_PingDecodeErrorZPtr {
-                       result: Box::into_raw(Box::new(o)),
-               },
-               result_ok: true,
+impl CVec_UpdateFailMalformedHTLCZ {
+       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::lightning::ln::msgs::UpdateFailMalformedHTLC> {
+               if self.datalen == 0 { return Vec::new(); }
+               let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
+               self.data = std::ptr::null_mut();
+               self.datalen = 0;
+               ret
+       }
+       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::lightning::ln::msgs::UpdateFailMalformedHTLC] {
+               unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
        }
 }
-#[no_mangle]
-/// Creates a new CResult_PingDecodeErrorZ in the error state.
-pub extern "C" fn CResult_PingDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_PingDecodeErrorZ {
-       CResult_PingDecodeErrorZ {
-               contents: CResult_PingDecodeErrorZPtr {
-                       err: Box::into_raw(Box::new(e)),
-               },
-               result_ok: false,
+impl From<Vec<crate::lightning::ln::msgs::UpdateFailMalformedHTLC>> for CVec_UpdateFailMalformedHTLCZ {
+       fn from(v: Vec<crate::lightning::ln::msgs::UpdateFailMalformedHTLC>) -> Self {
+               let datalen = v.len();
+               let data = Box::into_raw(v.into_boxed_slice());
+               Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_PingDecodeErrorZ.
-pub extern "C" fn CResult_PingDecodeErrorZ_free(_res: CResult_PingDecodeErrorZ) { }
-impl Drop for CResult_PingDecodeErrorZ {
+/// Frees the buffer pointed to by `data` if `datalen` is non-0.
+pub extern "C" fn CVec_UpdateFailMalformedHTLCZ_free(_res: CVec_UpdateFailMalformedHTLCZ) { }
+impl Drop for CVec_UpdateFailMalformedHTLCZ {
        fn drop(&mut self) {
-               if self.result_ok {
-                       if unsafe { !(self.contents.result as *mut ()).is_null() } {
-                               let _ = unsafe { Box::from_raw(self.contents.result) };
-                       }
-               } else {
-                       if unsafe { !(self.contents.err as *mut ()).is_null() } {
-                               let _ = unsafe { Box::from_raw(self.contents.err) };
-                       }
-               }
-       }
-}
-impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::Ping, crate::lightning::ln::msgs::DecodeError>> for CResult_PingDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::Ping, crate::lightning::ln::msgs::DecodeError>) -> Self {
-               let contents = if o.result_ok {
-                       let result = unsafe { o.contents.result };
-                       unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_PingDecodeErrorZPtr { result }
-               } else {
-                       let err = unsafe { o.contents.err };
-                       unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_PingDecodeErrorZPtr { err }
-               };
-               Self {
-                       contents,
-                       result_ok: o.result_ok,
-               }
+               if self.datalen == 0 { return; }
+               unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
        }
 }
-impl Clone for CResult_PingDecodeErrorZ {
+impl Clone for CVec_UpdateFailMalformedHTLCZ {
        fn clone(&self) -> Self {
-               if self.result_ok {
-                       Self { result_ok: true, contents: CResult_PingDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::Ping>::clone(unsafe { &*self.contents.result })))
-                       } }
-               } else {
-                       Self { result_ok: false, contents: CResult_PingDecodeErrorZPtr {
-                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
-                       } }
-               }
+               let mut res = Vec::new();
+               if self.datalen == 0 { return Self::from(res); }
+               res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
+               Self::from(res)
        }
 }
-#[no_mangle]
-/// Creates a new CResult_PingDecodeErrorZ which has the same data as `orig`
-/// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_PingDecodeErrorZ_clone(orig: &CResult_PingDecodeErrorZ) -> CResult_PingDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_PongDecodeErrorZ
-pub union CResult_PongDecodeErrorZPtr {
+/// The contents of CResult_AcceptChannelDecodeErrorZ
+pub union CResult_AcceptChannelDecodeErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::ln::msgs::Pong,
+       pub result: *mut crate::lightning::ln::msgs::AcceptChannel,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
        pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// 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_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`.
-pub struct CResult_PongDecodeErrorZ {
-       /// The contents of this CResult_PongDecodeErrorZ, accessible via either
+pub struct CResult_AcceptChannelDecodeErrorZ {
+       /// The contents of this CResult_AcceptChannelDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_PongDecodeErrorZPtr,
-       /// Whether this CResult_PongDecodeErrorZ represents a success state.
+       pub contents: CResult_AcceptChannelDecodeErrorZPtr,
+       /// Whether this CResult_AcceptChannelDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_PongDecodeErrorZ in the success state.
-pub extern "C" fn CResult_PongDecodeErrorZ_ok(o: crate::lightning::ln::msgs::Pong) -> CResult_PongDecodeErrorZ {
-       CResult_PongDecodeErrorZ {
-               contents: CResult_PongDecodeErrorZPtr {
+/// Creates a new CResult_AcceptChannelDecodeErrorZ in the success state.
+pub extern "C" fn CResult_AcceptChannelDecodeErrorZ_ok(o: crate::lightning::ln::msgs::AcceptChannel) -> CResult_AcceptChannelDecodeErrorZ {
+       CResult_AcceptChannelDecodeErrorZ {
+               contents: CResult_AcceptChannelDecodeErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_PongDecodeErrorZ in the error state.
-pub extern "C" fn CResult_PongDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_PongDecodeErrorZ {
-       CResult_PongDecodeErrorZ {
-               contents: CResult_PongDecodeErrorZPtr {
+/// Creates a new CResult_AcceptChannelDecodeErrorZ in the error state.
+pub extern "C" fn CResult_AcceptChannelDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_AcceptChannelDecodeErrorZ {
+       CResult_AcceptChannelDecodeErrorZ {
+               contents: CResult_AcceptChannelDecodeErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_PongDecodeErrorZ.
-pub extern "C" fn CResult_PongDecodeErrorZ_free(_res: CResult_PongDecodeErrorZ) { }
-impl Drop for CResult_PongDecodeErrorZ {
+/// Frees any resources used by the CResult_AcceptChannelDecodeErrorZ.
+pub extern "C" fn CResult_AcceptChannelDecodeErrorZ_free(_res: CResult_AcceptChannelDecodeErrorZ) { }
+impl Drop for CResult_AcceptChannelDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -7905,16 +8184,16 @@ impl Drop for CResult_PongDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::Pong, crate::lightning::ln::msgs::DecodeError>> for CResult_PongDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::Pong, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::AcceptChannel, crate::lightning::ln::msgs::DecodeError>> for CResult_AcceptChannelDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::AcceptChannel, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_PongDecodeErrorZPtr { result }
+                       CResult_AcceptChannelDecodeErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_PongDecodeErrorZPtr { err }
+                       CResult_AcceptChannelDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -7922,68 +8201,68 @@ impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::Pong, crate::
                }
        }
 }
-impl Clone for CResult_PongDecodeErrorZ {
+impl Clone for CResult_AcceptChannelDecodeErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_PongDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::Pong>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_AcceptChannelDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::AcceptChannel>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_PongDecodeErrorZPtr {
+                       Self { result_ok: false, contents: CResult_AcceptChannelDecodeErrorZPtr {
                                err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_PongDecodeErrorZ which has the same data as `orig`
+/// Creates a new CResult_AcceptChannelDecodeErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_PongDecodeErrorZ_clone(orig: &CResult_PongDecodeErrorZ) -> CResult_PongDecodeErrorZ { orig.clone() }
+pub extern "C" fn CResult_AcceptChannelDecodeErrorZ_clone(orig: &CResult_AcceptChannelDecodeErrorZ) -> CResult_AcceptChannelDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_UnsignedChannelAnnouncementDecodeErrorZ
-pub union CResult_UnsignedChannelAnnouncementDecodeErrorZPtr {
+/// The contents of CResult_AnnouncementSignaturesDecodeErrorZ
+pub union CResult_AnnouncementSignaturesDecodeErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::ln::msgs::UnsignedChannelAnnouncement,
+       pub result: *mut crate::lightning::ln::msgs::AnnouncementSignatures,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
        pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// 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_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`.
-pub struct CResult_UnsignedChannelAnnouncementDecodeErrorZ {
-       /// The contents of this CResult_UnsignedChannelAnnouncementDecodeErrorZ, accessible via either
+pub struct CResult_AnnouncementSignaturesDecodeErrorZ {
+       /// The contents of this CResult_AnnouncementSignaturesDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_UnsignedChannelAnnouncementDecodeErrorZPtr,
-       /// Whether this CResult_UnsignedChannelAnnouncementDecodeErrorZ represents a success state.
+       pub contents: CResult_AnnouncementSignaturesDecodeErrorZPtr,
+       /// Whether this CResult_AnnouncementSignaturesDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_UnsignedChannelAnnouncementDecodeErrorZ in the success state.
-pub extern "C" fn CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o: crate::lightning::ln::msgs::UnsignedChannelAnnouncement) -> CResult_UnsignedChannelAnnouncementDecodeErrorZ {
-       CResult_UnsignedChannelAnnouncementDecodeErrorZ {
-               contents: CResult_UnsignedChannelAnnouncementDecodeErrorZPtr {
+/// Creates a new CResult_AnnouncementSignaturesDecodeErrorZ in the success state.
+pub extern "C" fn CResult_AnnouncementSignaturesDecodeErrorZ_ok(o: crate::lightning::ln::msgs::AnnouncementSignatures) -> CResult_AnnouncementSignaturesDecodeErrorZ {
+       CResult_AnnouncementSignaturesDecodeErrorZ {
+               contents: CResult_AnnouncementSignaturesDecodeErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_UnsignedChannelAnnouncementDecodeErrorZ in the error state.
-pub extern "C" fn CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_UnsignedChannelAnnouncementDecodeErrorZ {
-       CResult_UnsignedChannelAnnouncementDecodeErrorZ {
-               contents: CResult_UnsignedChannelAnnouncementDecodeErrorZPtr {
+/// Creates a new CResult_AnnouncementSignaturesDecodeErrorZ in the error state.
+pub extern "C" fn CResult_AnnouncementSignaturesDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_AnnouncementSignaturesDecodeErrorZ {
+       CResult_AnnouncementSignaturesDecodeErrorZ {
+               contents: CResult_AnnouncementSignaturesDecodeErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_UnsignedChannelAnnouncementDecodeErrorZ.
-pub extern "C" fn CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res: CResult_UnsignedChannelAnnouncementDecodeErrorZ) { }
-impl Drop for CResult_UnsignedChannelAnnouncementDecodeErrorZ {
+/// Frees any resources used by the CResult_AnnouncementSignaturesDecodeErrorZ.
+pub extern "C" fn CResult_AnnouncementSignaturesDecodeErrorZ_free(_res: CResult_AnnouncementSignaturesDecodeErrorZ) { }
+impl Drop for CResult_AnnouncementSignaturesDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -7996,16 +8275,16 @@ impl Drop for CResult_UnsignedChannelAnnouncementDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::UnsignedChannelAnnouncement, crate::lightning::ln::msgs::DecodeError>> for CResult_UnsignedChannelAnnouncementDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::UnsignedChannelAnnouncement, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::AnnouncementSignatures, crate::lightning::ln::msgs::DecodeError>> for CResult_AnnouncementSignaturesDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::AnnouncementSignatures, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_UnsignedChannelAnnouncementDecodeErrorZPtr { result }
+                       CResult_AnnouncementSignaturesDecodeErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_UnsignedChannelAnnouncementDecodeErrorZPtr { err }
+                       CResult_AnnouncementSignaturesDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -8013,68 +8292,68 @@ impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::UnsignedChann
                }
        }
 }
-impl Clone for CResult_UnsignedChannelAnnouncementDecodeErrorZ {
+impl Clone for CResult_AnnouncementSignaturesDecodeErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_UnsignedChannelAnnouncementDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::UnsignedChannelAnnouncement>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_AnnouncementSignaturesDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::AnnouncementSignatures>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_UnsignedChannelAnnouncementDecodeErrorZPtr {
+                       Self { result_ok: false, contents: CResult_AnnouncementSignaturesDecodeErrorZPtr {
                                err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_UnsignedChannelAnnouncementDecodeErrorZ which has the same data as `orig`
+/// Creates a new CResult_AnnouncementSignaturesDecodeErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig: &CResult_UnsignedChannelAnnouncementDecodeErrorZ) -> CResult_UnsignedChannelAnnouncementDecodeErrorZ { orig.clone() }
+pub extern "C" fn CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig: &CResult_AnnouncementSignaturesDecodeErrorZ) -> CResult_AnnouncementSignaturesDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_ChannelAnnouncementDecodeErrorZ
-pub union CResult_ChannelAnnouncementDecodeErrorZPtr {
+/// The contents of CResult_ChannelReestablishDecodeErrorZ
+pub union CResult_ChannelReestablishDecodeErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::ln::msgs::ChannelAnnouncement,
+       pub result: *mut crate::lightning::ln::msgs::ChannelReestablish,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
        pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// 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_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`.
-pub struct CResult_ChannelAnnouncementDecodeErrorZ {
-       /// The contents of this CResult_ChannelAnnouncementDecodeErrorZ, accessible via either
+pub struct CResult_ChannelReestablishDecodeErrorZ {
+       /// The contents of this CResult_ChannelReestablishDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_ChannelAnnouncementDecodeErrorZPtr,
-       /// Whether this CResult_ChannelAnnouncementDecodeErrorZ represents a success state.
+       pub contents: CResult_ChannelReestablishDecodeErrorZPtr,
+       /// Whether this CResult_ChannelReestablishDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
-#[no_mangle]
-/// Creates a new CResult_ChannelAnnouncementDecodeErrorZ in the success state.
-pub extern "C" fn CResult_ChannelAnnouncementDecodeErrorZ_ok(o: crate::lightning::ln::msgs::ChannelAnnouncement) -> CResult_ChannelAnnouncementDecodeErrorZ {
-       CResult_ChannelAnnouncementDecodeErrorZ {
-               contents: CResult_ChannelAnnouncementDecodeErrorZPtr {
+#[no_mangle]
+/// Creates a new CResult_ChannelReestablishDecodeErrorZ in the success state.
+pub extern "C" fn CResult_ChannelReestablishDecodeErrorZ_ok(o: crate::lightning::ln::msgs::ChannelReestablish) -> CResult_ChannelReestablishDecodeErrorZ {
+       CResult_ChannelReestablishDecodeErrorZ {
+               contents: CResult_ChannelReestablishDecodeErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_ChannelAnnouncementDecodeErrorZ in the error state.
-pub extern "C" fn CResult_ChannelAnnouncementDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_ChannelAnnouncementDecodeErrorZ {
-       CResult_ChannelAnnouncementDecodeErrorZ {
-               contents: CResult_ChannelAnnouncementDecodeErrorZPtr {
+/// Creates a new CResult_ChannelReestablishDecodeErrorZ in the error state.
+pub extern "C" fn CResult_ChannelReestablishDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_ChannelReestablishDecodeErrorZ {
+       CResult_ChannelReestablishDecodeErrorZ {
+               contents: CResult_ChannelReestablishDecodeErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_ChannelAnnouncementDecodeErrorZ.
-pub extern "C" fn CResult_ChannelAnnouncementDecodeErrorZ_free(_res: CResult_ChannelAnnouncementDecodeErrorZ) { }
-impl Drop for CResult_ChannelAnnouncementDecodeErrorZ {
+/// Frees any resources used by the CResult_ChannelReestablishDecodeErrorZ.
+pub extern "C" fn CResult_ChannelReestablishDecodeErrorZ_free(_res: CResult_ChannelReestablishDecodeErrorZ) { }
+impl Drop for CResult_ChannelReestablishDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -8087,16 +8366,16 @@ impl Drop for CResult_ChannelAnnouncementDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::ChannelAnnouncement, crate::lightning::ln::msgs::DecodeError>> for CResult_ChannelAnnouncementDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::ChannelAnnouncement, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::ChannelReestablish, crate::lightning::ln::msgs::DecodeError>> for CResult_ChannelReestablishDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::ChannelReestablish, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_ChannelAnnouncementDecodeErrorZPtr { result }
+                       CResult_ChannelReestablishDecodeErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_ChannelAnnouncementDecodeErrorZPtr { err }
+                       CResult_ChannelReestablishDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -8104,68 +8383,68 @@ impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::ChannelAnnoun
                }
        }
 }
-impl Clone for CResult_ChannelAnnouncementDecodeErrorZ {
+impl Clone for CResult_ChannelReestablishDecodeErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_ChannelAnnouncementDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::ChannelAnnouncement>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_ChannelReestablishDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::ChannelReestablish>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_ChannelAnnouncementDecodeErrorZPtr {
+                       Self { result_ok: false, contents: CResult_ChannelReestablishDecodeErrorZPtr {
                                err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_ChannelAnnouncementDecodeErrorZ which has the same data as `orig`
+/// Creates a new CResult_ChannelReestablishDecodeErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_ChannelAnnouncementDecodeErrorZ_clone(orig: &CResult_ChannelAnnouncementDecodeErrorZ) -> CResult_ChannelAnnouncementDecodeErrorZ { orig.clone() }
+pub extern "C" fn CResult_ChannelReestablishDecodeErrorZ_clone(orig: &CResult_ChannelReestablishDecodeErrorZ) -> CResult_ChannelReestablishDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_UnsignedChannelUpdateDecodeErrorZ
-pub union CResult_UnsignedChannelUpdateDecodeErrorZPtr {
+/// The contents of CResult_ClosingSignedDecodeErrorZ
+pub union CResult_ClosingSignedDecodeErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::ln::msgs::UnsignedChannelUpdate,
+       pub result: *mut crate::lightning::ln::msgs::ClosingSigned,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
        pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// 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_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`.
-pub struct CResult_UnsignedChannelUpdateDecodeErrorZ {
-       /// The contents of this CResult_UnsignedChannelUpdateDecodeErrorZ, accessible via either
+pub struct CResult_ClosingSignedDecodeErrorZ {
+       /// The contents of this CResult_ClosingSignedDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_UnsignedChannelUpdateDecodeErrorZPtr,
-       /// Whether this CResult_UnsignedChannelUpdateDecodeErrorZ represents a success state.
+       pub contents: CResult_ClosingSignedDecodeErrorZPtr,
+       /// Whether this CResult_ClosingSignedDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_UnsignedChannelUpdateDecodeErrorZ in the success state.
-pub extern "C" fn CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o: crate::lightning::ln::msgs::UnsignedChannelUpdate) -> CResult_UnsignedChannelUpdateDecodeErrorZ {
-       CResult_UnsignedChannelUpdateDecodeErrorZ {
-               contents: CResult_UnsignedChannelUpdateDecodeErrorZPtr {
+/// Creates a new CResult_ClosingSignedDecodeErrorZ in the success state.
+pub extern "C" fn CResult_ClosingSignedDecodeErrorZ_ok(o: crate::lightning::ln::msgs::ClosingSigned) -> CResult_ClosingSignedDecodeErrorZ {
+       CResult_ClosingSignedDecodeErrorZ {
+               contents: CResult_ClosingSignedDecodeErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_UnsignedChannelUpdateDecodeErrorZ in the error state.
-pub extern "C" fn CResult_UnsignedChannelUpdateDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_UnsignedChannelUpdateDecodeErrorZ {
-       CResult_UnsignedChannelUpdateDecodeErrorZ {
-               contents: CResult_UnsignedChannelUpdateDecodeErrorZPtr {
+/// Creates a new CResult_ClosingSignedDecodeErrorZ in the error state.
+pub extern "C" fn CResult_ClosingSignedDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_ClosingSignedDecodeErrorZ {
+       CResult_ClosingSignedDecodeErrorZ {
+               contents: CResult_ClosingSignedDecodeErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_UnsignedChannelUpdateDecodeErrorZ.
-pub extern "C" fn CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res: CResult_UnsignedChannelUpdateDecodeErrorZ) { }
-impl Drop for CResult_UnsignedChannelUpdateDecodeErrorZ {
+/// Frees any resources used by the CResult_ClosingSignedDecodeErrorZ.
+pub extern "C" fn CResult_ClosingSignedDecodeErrorZ_free(_res: CResult_ClosingSignedDecodeErrorZ) { }
+impl Drop for CResult_ClosingSignedDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -8178,16 +8457,16 @@ impl Drop for CResult_UnsignedChannelUpdateDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::UnsignedChannelUpdate, crate::lightning::ln::msgs::DecodeError>> for CResult_UnsignedChannelUpdateDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::UnsignedChannelUpdate, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::ClosingSigned, crate::lightning::ln::msgs::DecodeError>> for CResult_ClosingSignedDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::ClosingSigned, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_UnsignedChannelUpdateDecodeErrorZPtr { result }
+                       CResult_ClosingSignedDecodeErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_UnsignedChannelUpdateDecodeErrorZPtr { err }
+                       CResult_ClosingSignedDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -8195,68 +8474,68 @@ impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::UnsignedChann
                }
        }
 }
-impl Clone for CResult_UnsignedChannelUpdateDecodeErrorZ {
+impl Clone for CResult_ClosingSignedDecodeErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_UnsignedChannelUpdateDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::UnsignedChannelUpdate>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_ClosingSignedDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::ClosingSigned>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_UnsignedChannelUpdateDecodeErrorZPtr {
+                       Self { result_ok: false, contents: CResult_ClosingSignedDecodeErrorZPtr {
                                err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_UnsignedChannelUpdateDecodeErrorZ which has the same data as `orig`
+/// Creates a new CResult_ClosingSignedDecodeErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig: &CResult_UnsignedChannelUpdateDecodeErrorZ) -> CResult_UnsignedChannelUpdateDecodeErrorZ { orig.clone() }
+pub extern "C" fn CResult_ClosingSignedDecodeErrorZ_clone(orig: &CResult_ClosingSignedDecodeErrorZ) -> CResult_ClosingSignedDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_ChannelUpdateDecodeErrorZ
-pub union CResult_ChannelUpdateDecodeErrorZPtr {
+/// The contents of CResult_CommitmentSignedDecodeErrorZ
+pub union CResult_CommitmentSignedDecodeErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::ln::msgs::ChannelUpdate,
+       pub result: *mut crate::lightning::ln::msgs::CommitmentSigned,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
        pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// 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_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`.
-pub struct CResult_ChannelUpdateDecodeErrorZ {
-       /// The contents of this CResult_ChannelUpdateDecodeErrorZ, accessible via either
+pub struct CResult_CommitmentSignedDecodeErrorZ {
+       /// The contents of this CResult_CommitmentSignedDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_ChannelUpdateDecodeErrorZPtr,
-       /// Whether this CResult_ChannelUpdateDecodeErrorZ represents a success state.
+       pub contents: CResult_CommitmentSignedDecodeErrorZPtr,
+       /// Whether this CResult_CommitmentSignedDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_ChannelUpdateDecodeErrorZ in the success state.
-pub extern "C" fn CResult_ChannelUpdateDecodeErrorZ_ok(o: crate::lightning::ln::msgs::ChannelUpdate) -> CResult_ChannelUpdateDecodeErrorZ {
-       CResult_ChannelUpdateDecodeErrorZ {
-               contents: CResult_ChannelUpdateDecodeErrorZPtr {
+/// Creates a new CResult_CommitmentSignedDecodeErrorZ in the success state.
+pub extern "C" fn CResult_CommitmentSignedDecodeErrorZ_ok(o: crate::lightning::ln::msgs::CommitmentSigned) -> CResult_CommitmentSignedDecodeErrorZ {
+       CResult_CommitmentSignedDecodeErrorZ {
+               contents: CResult_CommitmentSignedDecodeErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_ChannelUpdateDecodeErrorZ in the error state.
-pub extern "C" fn CResult_ChannelUpdateDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_ChannelUpdateDecodeErrorZ {
-       CResult_ChannelUpdateDecodeErrorZ {
-               contents: CResult_ChannelUpdateDecodeErrorZPtr {
+/// Creates a new CResult_CommitmentSignedDecodeErrorZ in the error state.
+pub extern "C" fn CResult_CommitmentSignedDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_CommitmentSignedDecodeErrorZ {
+       CResult_CommitmentSignedDecodeErrorZ {
+               contents: CResult_CommitmentSignedDecodeErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_ChannelUpdateDecodeErrorZ.
-pub extern "C" fn CResult_ChannelUpdateDecodeErrorZ_free(_res: CResult_ChannelUpdateDecodeErrorZ) { }
-impl Drop for CResult_ChannelUpdateDecodeErrorZ {
+/// Frees any resources used by the CResult_CommitmentSignedDecodeErrorZ.
+pub extern "C" fn CResult_CommitmentSignedDecodeErrorZ_free(_res: CResult_CommitmentSignedDecodeErrorZ) { }
+impl Drop for CResult_CommitmentSignedDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -8269,16 +8548,16 @@ impl Drop for CResult_ChannelUpdateDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::ChannelUpdate, crate::lightning::ln::msgs::DecodeError>> for CResult_ChannelUpdateDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::ChannelUpdate, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::CommitmentSigned, crate::lightning::ln::msgs::DecodeError>> for CResult_CommitmentSignedDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::CommitmentSigned, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_ChannelUpdateDecodeErrorZPtr { result }
+                       CResult_CommitmentSignedDecodeErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_ChannelUpdateDecodeErrorZPtr { err }
+                       CResult_CommitmentSignedDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -8286,68 +8565,68 @@ impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::ChannelUpdate
                }
        }
 }
-impl Clone for CResult_ChannelUpdateDecodeErrorZ {
+impl Clone for CResult_CommitmentSignedDecodeErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_ChannelUpdateDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::ChannelUpdate>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_CommitmentSignedDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::CommitmentSigned>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_ChannelUpdateDecodeErrorZPtr {
+                       Self { result_ok: false, contents: CResult_CommitmentSignedDecodeErrorZPtr {
                                err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_ChannelUpdateDecodeErrorZ which has the same data as `orig`
+/// Creates a new CResult_CommitmentSignedDecodeErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_ChannelUpdateDecodeErrorZ_clone(orig: &CResult_ChannelUpdateDecodeErrorZ) -> CResult_ChannelUpdateDecodeErrorZ { orig.clone() }
+pub extern "C" fn CResult_CommitmentSignedDecodeErrorZ_clone(orig: &CResult_CommitmentSignedDecodeErrorZ) -> CResult_CommitmentSignedDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_ErrorMessageDecodeErrorZ
-pub union CResult_ErrorMessageDecodeErrorZPtr {
+/// The contents of CResult_FundingCreatedDecodeErrorZ
+pub union CResult_FundingCreatedDecodeErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::ln::msgs::ErrorMessage,
+       pub result: *mut crate::lightning::ln::msgs::FundingCreated,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
        pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// 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_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`.
-pub struct CResult_ErrorMessageDecodeErrorZ {
-       /// The contents of this CResult_ErrorMessageDecodeErrorZ, accessible via either
+pub struct CResult_FundingCreatedDecodeErrorZ {
+       /// The contents of this CResult_FundingCreatedDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_ErrorMessageDecodeErrorZPtr,
-       /// Whether this CResult_ErrorMessageDecodeErrorZ represents a success state.
+       pub contents: CResult_FundingCreatedDecodeErrorZPtr,
+       /// Whether this CResult_FundingCreatedDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_ErrorMessageDecodeErrorZ in the success state.
-pub extern "C" fn CResult_ErrorMessageDecodeErrorZ_ok(o: crate::lightning::ln::msgs::ErrorMessage) -> CResult_ErrorMessageDecodeErrorZ {
-       CResult_ErrorMessageDecodeErrorZ {
-               contents: CResult_ErrorMessageDecodeErrorZPtr {
+/// Creates a new CResult_FundingCreatedDecodeErrorZ in the success state.
+pub extern "C" fn CResult_FundingCreatedDecodeErrorZ_ok(o: crate::lightning::ln::msgs::FundingCreated) -> CResult_FundingCreatedDecodeErrorZ {
+       CResult_FundingCreatedDecodeErrorZ {
+               contents: CResult_FundingCreatedDecodeErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_ErrorMessageDecodeErrorZ in the error state.
-pub extern "C" fn CResult_ErrorMessageDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_ErrorMessageDecodeErrorZ {
-       CResult_ErrorMessageDecodeErrorZ {
-               contents: CResult_ErrorMessageDecodeErrorZPtr {
+/// Creates a new CResult_FundingCreatedDecodeErrorZ in the error state.
+pub extern "C" fn CResult_FundingCreatedDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_FundingCreatedDecodeErrorZ {
+       CResult_FundingCreatedDecodeErrorZ {
+               contents: CResult_FundingCreatedDecodeErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_ErrorMessageDecodeErrorZ.
-pub extern "C" fn CResult_ErrorMessageDecodeErrorZ_free(_res: CResult_ErrorMessageDecodeErrorZ) { }
-impl Drop for CResult_ErrorMessageDecodeErrorZ {
+/// Frees any resources used by the CResult_FundingCreatedDecodeErrorZ.
+pub extern "C" fn CResult_FundingCreatedDecodeErrorZ_free(_res: CResult_FundingCreatedDecodeErrorZ) { }
+impl Drop for CResult_FundingCreatedDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -8360,16 +8639,16 @@ impl Drop for CResult_ErrorMessageDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::ErrorMessage, crate::lightning::ln::msgs::DecodeError>> for CResult_ErrorMessageDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::ErrorMessage, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::FundingCreated, crate::lightning::ln::msgs::DecodeError>> for CResult_FundingCreatedDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::FundingCreated, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_ErrorMessageDecodeErrorZPtr { result }
+                       CResult_FundingCreatedDecodeErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_ErrorMessageDecodeErrorZPtr { err }
+                       CResult_FundingCreatedDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -8377,68 +8656,68 @@ impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::ErrorMessage,
                }
        }
 }
-impl Clone for CResult_ErrorMessageDecodeErrorZ {
+impl Clone for CResult_FundingCreatedDecodeErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_ErrorMessageDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::ErrorMessage>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_FundingCreatedDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::FundingCreated>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_ErrorMessageDecodeErrorZPtr {
+                       Self { result_ok: false, contents: CResult_FundingCreatedDecodeErrorZPtr {
                                err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_ErrorMessageDecodeErrorZ which has the same data as `orig`
+/// Creates a new CResult_FundingCreatedDecodeErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_ErrorMessageDecodeErrorZ_clone(orig: &CResult_ErrorMessageDecodeErrorZ) -> CResult_ErrorMessageDecodeErrorZ { orig.clone() }
+pub extern "C" fn CResult_FundingCreatedDecodeErrorZ_clone(orig: &CResult_FundingCreatedDecodeErrorZ) -> CResult_FundingCreatedDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_UnsignedNodeAnnouncementDecodeErrorZ
-pub union CResult_UnsignedNodeAnnouncementDecodeErrorZPtr {
+/// The contents of CResult_FundingSignedDecodeErrorZ
+pub union CResult_FundingSignedDecodeErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::ln::msgs::UnsignedNodeAnnouncement,
+       pub result: *mut crate::lightning::ln::msgs::FundingSigned,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
        pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// 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_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`.
-pub struct CResult_UnsignedNodeAnnouncementDecodeErrorZ {
-       /// The contents of this CResult_UnsignedNodeAnnouncementDecodeErrorZ, accessible via either
+pub struct CResult_FundingSignedDecodeErrorZ {
+       /// The contents of this CResult_FundingSignedDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_UnsignedNodeAnnouncementDecodeErrorZPtr,
-       /// Whether this CResult_UnsignedNodeAnnouncementDecodeErrorZ represents a success state.
+       pub contents: CResult_FundingSignedDecodeErrorZPtr,
+       /// Whether this CResult_FundingSignedDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_UnsignedNodeAnnouncementDecodeErrorZ in the success state.
-pub extern "C" fn CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o: crate::lightning::ln::msgs::UnsignedNodeAnnouncement) -> CResult_UnsignedNodeAnnouncementDecodeErrorZ {
-       CResult_UnsignedNodeAnnouncementDecodeErrorZ {
-               contents: CResult_UnsignedNodeAnnouncementDecodeErrorZPtr {
+/// Creates a new CResult_FundingSignedDecodeErrorZ in the success state.
+pub extern "C" fn CResult_FundingSignedDecodeErrorZ_ok(o: crate::lightning::ln::msgs::FundingSigned) -> CResult_FundingSignedDecodeErrorZ {
+       CResult_FundingSignedDecodeErrorZ {
+               contents: CResult_FundingSignedDecodeErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_UnsignedNodeAnnouncementDecodeErrorZ in the error state.
-pub extern "C" fn CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_UnsignedNodeAnnouncementDecodeErrorZ {
-       CResult_UnsignedNodeAnnouncementDecodeErrorZ {
-               contents: CResult_UnsignedNodeAnnouncementDecodeErrorZPtr {
+/// Creates a new CResult_FundingSignedDecodeErrorZ in the error state.
+pub extern "C" fn CResult_FundingSignedDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_FundingSignedDecodeErrorZ {
+       CResult_FundingSignedDecodeErrorZ {
+               contents: CResult_FundingSignedDecodeErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_UnsignedNodeAnnouncementDecodeErrorZ.
-pub extern "C" fn CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res: CResult_UnsignedNodeAnnouncementDecodeErrorZ) { }
-impl Drop for CResult_UnsignedNodeAnnouncementDecodeErrorZ {
+/// Frees any resources used by the CResult_FundingSignedDecodeErrorZ.
+pub extern "C" fn CResult_FundingSignedDecodeErrorZ_free(_res: CResult_FundingSignedDecodeErrorZ) { }
+impl Drop for CResult_FundingSignedDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -8451,16 +8730,16 @@ impl Drop for CResult_UnsignedNodeAnnouncementDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::UnsignedNodeAnnouncement, crate::lightning::ln::msgs::DecodeError>> for CResult_UnsignedNodeAnnouncementDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::UnsignedNodeAnnouncement, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::FundingSigned, crate::lightning::ln::msgs::DecodeError>> for CResult_FundingSignedDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::FundingSigned, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_UnsignedNodeAnnouncementDecodeErrorZPtr { result }
+                       CResult_FundingSignedDecodeErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_UnsignedNodeAnnouncementDecodeErrorZPtr { err }
+                       CResult_FundingSignedDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -8468,68 +8747,68 @@ impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::UnsignedNodeA
                }
        }
 }
-impl Clone for CResult_UnsignedNodeAnnouncementDecodeErrorZ {
+impl Clone for CResult_FundingSignedDecodeErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_UnsignedNodeAnnouncementDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::UnsignedNodeAnnouncement>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_FundingSignedDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::FundingSigned>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_UnsignedNodeAnnouncementDecodeErrorZPtr {
+                       Self { result_ok: false, contents: CResult_FundingSignedDecodeErrorZPtr {
                                err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_UnsignedNodeAnnouncementDecodeErrorZ which has the same data as `orig`
+/// Creates a new CResult_FundingSignedDecodeErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig: &CResult_UnsignedNodeAnnouncementDecodeErrorZ) -> CResult_UnsignedNodeAnnouncementDecodeErrorZ { orig.clone() }
+pub extern "C" fn CResult_FundingSignedDecodeErrorZ_clone(orig: &CResult_FundingSignedDecodeErrorZ) -> CResult_FundingSignedDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_NodeAnnouncementDecodeErrorZ
-pub union CResult_NodeAnnouncementDecodeErrorZPtr {
+/// The contents of CResult_FundingLockedDecodeErrorZ
+pub union CResult_FundingLockedDecodeErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::ln::msgs::NodeAnnouncement,
+       pub result: *mut crate::lightning::ln::msgs::FundingLocked,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
        pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// 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_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`.
-pub struct CResult_NodeAnnouncementDecodeErrorZ {
-       /// The contents of this CResult_NodeAnnouncementDecodeErrorZ, accessible via either
+pub struct CResult_FundingLockedDecodeErrorZ {
+       /// The contents of this CResult_FundingLockedDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_NodeAnnouncementDecodeErrorZPtr,
-       /// Whether this CResult_NodeAnnouncementDecodeErrorZ represents a success state.
+       pub contents: CResult_FundingLockedDecodeErrorZPtr,
+       /// Whether this CResult_FundingLockedDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_NodeAnnouncementDecodeErrorZ in the success state.
-pub extern "C" fn CResult_NodeAnnouncementDecodeErrorZ_ok(o: crate::lightning::ln::msgs::NodeAnnouncement) -> CResult_NodeAnnouncementDecodeErrorZ {
-       CResult_NodeAnnouncementDecodeErrorZ {
-               contents: CResult_NodeAnnouncementDecodeErrorZPtr {
+/// Creates a new CResult_FundingLockedDecodeErrorZ in the success state.
+pub extern "C" fn CResult_FundingLockedDecodeErrorZ_ok(o: crate::lightning::ln::msgs::FundingLocked) -> CResult_FundingLockedDecodeErrorZ {
+       CResult_FundingLockedDecodeErrorZ {
+               contents: CResult_FundingLockedDecodeErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_NodeAnnouncementDecodeErrorZ in the error state.
-pub extern "C" fn CResult_NodeAnnouncementDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_NodeAnnouncementDecodeErrorZ {
-       CResult_NodeAnnouncementDecodeErrorZ {
-               contents: CResult_NodeAnnouncementDecodeErrorZPtr {
+/// Creates a new CResult_FundingLockedDecodeErrorZ in the error state.
+pub extern "C" fn CResult_FundingLockedDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_FundingLockedDecodeErrorZ {
+       CResult_FundingLockedDecodeErrorZ {
+               contents: CResult_FundingLockedDecodeErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_NodeAnnouncementDecodeErrorZ.
-pub extern "C" fn CResult_NodeAnnouncementDecodeErrorZ_free(_res: CResult_NodeAnnouncementDecodeErrorZ) { }
-impl Drop for CResult_NodeAnnouncementDecodeErrorZ {
+/// Frees any resources used by the CResult_FundingLockedDecodeErrorZ.
+pub extern "C" fn CResult_FundingLockedDecodeErrorZ_free(_res: CResult_FundingLockedDecodeErrorZ) { }
+impl Drop for CResult_FundingLockedDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -8542,16 +8821,16 @@ impl Drop for CResult_NodeAnnouncementDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::NodeAnnouncement, crate::lightning::ln::msgs::DecodeError>> for CResult_NodeAnnouncementDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::NodeAnnouncement, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::FundingLocked, crate::lightning::ln::msgs::DecodeError>> for CResult_FundingLockedDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::FundingLocked, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_NodeAnnouncementDecodeErrorZPtr { result }
+                       CResult_FundingLockedDecodeErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_NodeAnnouncementDecodeErrorZPtr { err }
+                       CResult_FundingLockedDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -8559,68 +8838,68 @@ impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::NodeAnnouncem
                }
        }
 }
-impl Clone for CResult_NodeAnnouncementDecodeErrorZ {
+impl Clone for CResult_FundingLockedDecodeErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_NodeAnnouncementDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::NodeAnnouncement>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_FundingLockedDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::FundingLocked>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_NodeAnnouncementDecodeErrorZPtr {
+                       Self { result_ok: false, contents: CResult_FundingLockedDecodeErrorZPtr {
                                err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_NodeAnnouncementDecodeErrorZ which has the same data as `orig`
+/// Creates a new CResult_FundingLockedDecodeErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_NodeAnnouncementDecodeErrorZ_clone(orig: &CResult_NodeAnnouncementDecodeErrorZ) -> CResult_NodeAnnouncementDecodeErrorZ { orig.clone() }
+pub extern "C" fn CResult_FundingLockedDecodeErrorZ_clone(orig: &CResult_FundingLockedDecodeErrorZ) -> CResult_FundingLockedDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_QueryShortChannelIdsDecodeErrorZ
-pub union CResult_QueryShortChannelIdsDecodeErrorZPtr {
+/// The contents of CResult_InitDecodeErrorZ
+pub union CResult_InitDecodeErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::ln::msgs::QueryShortChannelIds,
+       pub result: *mut crate::lightning::ln::msgs::Init,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
        pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// 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_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`.
-pub struct CResult_QueryShortChannelIdsDecodeErrorZ {
-       /// The contents of this CResult_QueryShortChannelIdsDecodeErrorZ, accessible via either
+pub struct CResult_InitDecodeErrorZ {
+       /// The contents of this CResult_InitDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_QueryShortChannelIdsDecodeErrorZPtr,
-       /// Whether this CResult_QueryShortChannelIdsDecodeErrorZ represents a success state.
+       pub contents: CResult_InitDecodeErrorZPtr,
+       /// Whether this CResult_InitDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_QueryShortChannelIdsDecodeErrorZ in the success state.
-pub extern "C" fn CResult_QueryShortChannelIdsDecodeErrorZ_ok(o: crate::lightning::ln::msgs::QueryShortChannelIds) -> CResult_QueryShortChannelIdsDecodeErrorZ {
-       CResult_QueryShortChannelIdsDecodeErrorZ {
-               contents: CResult_QueryShortChannelIdsDecodeErrorZPtr {
+/// Creates a new CResult_InitDecodeErrorZ in the success state.
+pub extern "C" fn CResult_InitDecodeErrorZ_ok(o: crate::lightning::ln::msgs::Init) -> CResult_InitDecodeErrorZ {
+       CResult_InitDecodeErrorZ {
+               contents: CResult_InitDecodeErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_QueryShortChannelIdsDecodeErrorZ in the error state.
-pub extern "C" fn CResult_QueryShortChannelIdsDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_QueryShortChannelIdsDecodeErrorZ {
-       CResult_QueryShortChannelIdsDecodeErrorZ {
-               contents: CResult_QueryShortChannelIdsDecodeErrorZPtr {
+/// Creates a new CResult_InitDecodeErrorZ in the error state.
+pub extern "C" fn CResult_InitDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_InitDecodeErrorZ {
+       CResult_InitDecodeErrorZ {
+               contents: CResult_InitDecodeErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_QueryShortChannelIdsDecodeErrorZ.
-pub extern "C" fn CResult_QueryShortChannelIdsDecodeErrorZ_free(_res: CResult_QueryShortChannelIdsDecodeErrorZ) { }
-impl Drop for CResult_QueryShortChannelIdsDecodeErrorZ {
+/// Frees any resources used by the CResult_InitDecodeErrorZ.
+pub extern "C" fn CResult_InitDecodeErrorZ_free(_res: CResult_InitDecodeErrorZ) { }
+impl Drop for CResult_InitDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -8633,16 +8912,16 @@ impl Drop for CResult_QueryShortChannelIdsDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::QueryShortChannelIds, crate::lightning::ln::msgs::DecodeError>> for CResult_QueryShortChannelIdsDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::QueryShortChannelIds, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::Init, crate::lightning::ln::msgs::DecodeError>> for CResult_InitDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::Init, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_QueryShortChannelIdsDecodeErrorZPtr { result }
+                       CResult_InitDecodeErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_QueryShortChannelIdsDecodeErrorZPtr { err }
+                       CResult_InitDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -8650,68 +8929,68 @@ impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::QueryShortCha
                }
        }
 }
-impl Clone for CResult_QueryShortChannelIdsDecodeErrorZ {
+impl Clone for CResult_InitDecodeErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_QueryShortChannelIdsDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::QueryShortChannelIds>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_InitDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::Init>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_QueryShortChannelIdsDecodeErrorZPtr {
+                       Self { result_ok: false, contents: CResult_InitDecodeErrorZPtr {
                                err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_QueryShortChannelIdsDecodeErrorZ which has the same data as `orig`
+/// Creates a new CResult_InitDecodeErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig: &CResult_QueryShortChannelIdsDecodeErrorZ) -> CResult_QueryShortChannelIdsDecodeErrorZ { orig.clone() }
+pub extern "C" fn CResult_InitDecodeErrorZ_clone(orig: &CResult_InitDecodeErrorZ) -> CResult_InitDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_ReplyShortChannelIdsEndDecodeErrorZ
-pub union CResult_ReplyShortChannelIdsEndDecodeErrorZPtr {
+/// The contents of CResult_OpenChannelDecodeErrorZ
+pub union CResult_OpenChannelDecodeErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::ln::msgs::ReplyShortChannelIdsEnd,
+       pub result: *mut crate::lightning::ln::msgs::OpenChannel,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
        pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// 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_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`.
-pub struct CResult_ReplyShortChannelIdsEndDecodeErrorZ {
-       /// The contents of this CResult_ReplyShortChannelIdsEndDecodeErrorZ, accessible via either
+pub struct CResult_OpenChannelDecodeErrorZ {
+       /// The contents of this CResult_OpenChannelDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_ReplyShortChannelIdsEndDecodeErrorZPtr,
-       /// Whether this CResult_ReplyShortChannelIdsEndDecodeErrorZ represents a success state.
+       pub contents: CResult_OpenChannelDecodeErrorZPtr,
+       /// Whether this CResult_OpenChannelDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_ReplyShortChannelIdsEndDecodeErrorZ in the success state.
-pub extern "C" fn CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o: crate::lightning::ln::msgs::ReplyShortChannelIdsEnd) -> CResult_ReplyShortChannelIdsEndDecodeErrorZ {
-       CResult_ReplyShortChannelIdsEndDecodeErrorZ {
-               contents: CResult_ReplyShortChannelIdsEndDecodeErrorZPtr {
+/// Creates a new CResult_OpenChannelDecodeErrorZ in the success state.
+pub extern "C" fn CResult_OpenChannelDecodeErrorZ_ok(o: crate::lightning::ln::msgs::OpenChannel) -> CResult_OpenChannelDecodeErrorZ {
+       CResult_OpenChannelDecodeErrorZ {
+               contents: CResult_OpenChannelDecodeErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_ReplyShortChannelIdsEndDecodeErrorZ in the error state.
-pub extern "C" fn CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_ReplyShortChannelIdsEndDecodeErrorZ {
-       CResult_ReplyShortChannelIdsEndDecodeErrorZ {
-               contents: CResult_ReplyShortChannelIdsEndDecodeErrorZPtr {
+/// Creates a new CResult_OpenChannelDecodeErrorZ in the error state.
+pub extern "C" fn CResult_OpenChannelDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_OpenChannelDecodeErrorZ {
+       CResult_OpenChannelDecodeErrorZ {
+               contents: CResult_OpenChannelDecodeErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_ReplyShortChannelIdsEndDecodeErrorZ.
-pub extern "C" fn CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res: CResult_ReplyShortChannelIdsEndDecodeErrorZ) { }
-impl Drop for CResult_ReplyShortChannelIdsEndDecodeErrorZ {
+/// Frees any resources used by the CResult_OpenChannelDecodeErrorZ.
+pub extern "C" fn CResult_OpenChannelDecodeErrorZ_free(_res: CResult_OpenChannelDecodeErrorZ) { }
+impl Drop for CResult_OpenChannelDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -8724,16 +9003,16 @@ impl Drop for CResult_ReplyShortChannelIdsEndDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::ReplyShortChannelIdsEnd, crate::lightning::ln::msgs::DecodeError>> for CResult_ReplyShortChannelIdsEndDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::ReplyShortChannelIdsEnd, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::OpenChannel, crate::lightning::ln::msgs::DecodeError>> for CResult_OpenChannelDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::OpenChannel, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_ReplyShortChannelIdsEndDecodeErrorZPtr { result }
+                       CResult_OpenChannelDecodeErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_ReplyShortChannelIdsEndDecodeErrorZPtr { err }
+                       CResult_OpenChannelDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -8741,68 +9020,68 @@ impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::ReplyShortCha
                }
        }
 }
-impl Clone for CResult_ReplyShortChannelIdsEndDecodeErrorZ {
+impl Clone for CResult_OpenChannelDecodeErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_ReplyShortChannelIdsEndDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::ReplyShortChannelIdsEnd>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_OpenChannelDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::OpenChannel>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_ReplyShortChannelIdsEndDecodeErrorZPtr {
+                       Self { result_ok: false, contents: CResult_OpenChannelDecodeErrorZPtr {
                                err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_ReplyShortChannelIdsEndDecodeErrorZ which has the same data as `orig`
+/// Creates a new CResult_OpenChannelDecodeErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig: &CResult_ReplyShortChannelIdsEndDecodeErrorZ) -> CResult_ReplyShortChannelIdsEndDecodeErrorZ { orig.clone() }
+pub extern "C" fn CResult_OpenChannelDecodeErrorZ_clone(orig: &CResult_OpenChannelDecodeErrorZ) -> CResult_OpenChannelDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_QueryChannelRangeDecodeErrorZ
-pub union CResult_QueryChannelRangeDecodeErrorZPtr {
+/// The contents of CResult_RevokeAndACKDecodeErrorZ
+pub union CResult_RevokeAndACKDecodeErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::ln::msgs::QueryChannelRange,
+       pub result: *mut crate::lightning::ln::msgs::RevokeAndACK,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
        pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(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.
+/// 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`.
-pub struct CResult_QueryChannelRangeDecodeErrorZ {
-       /// The contents of this CResult_QueryChannelRangeDecodeErrorZ, accessible via either
+pub struct CResult_RevokeAndACKDecodeErrorZ {
+       /// The contents of this CResult_RevokeAndACKDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_QueryChannelRangeDecodeErrorZPtr,
-       /// Whether this CResult_QueryChannelRangeDecodeErrorZ represents a success state.
+       pub contents: CResult_RevokeAndACKDecodeErrorZPtr,
+       /// Whether this CResult_RevokeAndACKDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_QueryChannelRangeDecodeErrorZ in the success state.
-pub extern "C" fn CResult_QueryChannelRangeDecodeErrorZ_ok(o: crate::lightning::ln::msgs::QueryChannelRange) -> CResult_QueryChannelRangeDecodeErrorZ {
-       CResult_QueryChannelRangeDecodeErrorZ {
-               contents: CResult_QueryChannelRangeDecodeErrorZPtr {
+/// Creates a new CResult_RevokeAndACKDecodeErrorZ in the success state.
+pub extern "C" fn CResult_RevokeAndACKDecodeErrorZ_ok(o: crate::lightning::ln::msgs::RevokeAndACK) -> CResult_RevokeAndACKDecodeErrorZ {
+       CResult_RevokeAndACKDecodeErrorZ {
+               contents: CResult_RevokeAndACKDecodeErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_QueryChannelRangeDecodeErrorZ in the error state.
-pub extern "C" fn CResult_QueryChannelRangeDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_QueryChannelRangeDecodeErrorZ {
-       CResult_QueryChannelRangeDecodeErrorZ {
-               contents: CResult_QueryChannelRangeDecodeErrorZPtr {
+/// Creates a new CResult_RevokeAndACKDecodeErrorZ in the error state.
+pub extern "C" fn CResult_RevokeAndACKDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_RevokeAndACKDecodeErrorZ {
+       CResult_RevokeAndACKDecodeErrorZ {
+               contents: CResult_RevokeAndACKDecodeErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_QueryChannelRangeDecodeErrorZ.
-pub extern "C" fn CResult_QueryChannelRangeDecodeErrorZ_free(_res: CResult_QueryChannelRangeDecodeErrorZ) { }
-impl Drop for CResult_QueryChannelRangeDecodeErrorZ {
+/// Frees any resources used by the CResult_RevokeAndACKDecodeErrorZ.
+pub extern "C" fn CResult_RevokeAndACKDecodeErrorZ_free(_res: CResult_RevokeAndACKDecodeErrorZ) { }
+impl Drop for CResult_RevokeAndACKDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -8815,16 +9094,16 @@ impl Drop for CResult_QueryChannelRangeDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::QueryChannelRange, crate::lightning::ln::msgs::DecodeError>> for CResult_QueryChannelRangeDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::QueryChannelRange, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::RevokeAndACK, crate::lightning::ln::msgs::DecodeError>> for CResult_RevokeAndACKDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::RevokeAndACK, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_QueryChannelRangeDecodeErrorZPtr { result }
+                       CResult_RevokeAndACKDecodeErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_QueryChannelRangeDecodeErrorZPtr { err }
+                       CResult_RevokeAndACKDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -8832,68 +9111,68 @@ impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::QueryChannelR
                }
        }
 }
-impl Clone for CResult_QueryChannelRangeDecodeErrorZ {
+impl Clone for CResult_RevokeAndACKDecodeErrorZ {
        fn clone(&self) -> Self {
-               if self.result_ok {
-                       Self { result_ok: true, contents: CResult_QueryChannelRangeDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::QueryChannelRange>::clone(unsafe { &*self.contents.result })))
+               if self.result_ok {
+                       Self { result_ok: true, contents: CResult_RevokeAndACKDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::RevokeAndACK>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_QueryChannelRangeDecodeErrorZPtr {
+                       Self { result_ok: false, contents: CResult_RevokeAndACKDecodeErrorZPtr {
                                err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_QueryChannelRangeDecodeErrorZ which has the same data as `orig`
+/// Creates a new CResult_RevokeAndACKDecodeErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_QueryChannelRangeDecodeErrorZ_clone(orig: &CResult_QueryChannelRangeDecodeErrorZ) -> CResult_QueryChannelRangeDecodeErrorZ { orig.clone() }
+pub extern "C" fn CResult_RevokeAndACKDecodeErrorZ_clone(orig: &CResult_RevokeAndACKDecodeErrorZ) -> CResult_RevokeAndACKDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_ReplyChannelRangeDecodeErrorZ
-pub union CResult_ReplyChannelRangeDecodeErrorZPtr {
+/// The contents of CResult_ShutdownDecodeErrorZ
+pub union CResult_ShutdownDecodeErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::ln::msgs::ReplyChannelRange,
+       pub result: *mut crate::lightning::ln::msgs::Shutdown,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
        pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// 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_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`.
-pub struct CResult_ReplyChannelRangeDecodeErrorZ {
-       /// The contents of this CResult_ReplyChannelRangeDecodeErrorZ, accessible via either
+pub struct CResult_ShutdownDecodeErrorZ {
+       /// The contents of this CResult_ShutdownDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_ReplyChannelRangeDecodeErrorZPtr,
-       /// Whether this CResult_ReplyChannelRangeDecodeErrorZ represents a success state.
+       pub contents: CResult_ShutdownDecodeErrorZPtr,
+       /// Whether this CResult_ShutdownDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_ReplyChannelRangeDecodeErrorZ in the success state.
-pub extern "C" fn CResult_ReplyChannelRangeDecodeErrorZ_ok(o: crate::lightning::ln::msgs::ReplyChannelRange) -> CResult_ReplyChannelRangeDecodeErrorZ {
-       CResult_ReplyChannelRangeDecodeErrorZ {
-               contents: CResult_ReplyChannelRangeDecodeErrorZPtr {
+/// Creates a new CResult_ShutdownDecodeErrorZ in the success state.
+pub extern "C" fn CResult_ShutdownDecodeErrorZ_ok(o: crate::lightning::ln::msgs::Shutdown) -> CResult_ShutdownDecodeErrorZ {
+       CResult_ShutdownDecodeErrorZ {
+               contents: CResult_ShutdownDecodeErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_ReplyChannelRangeDecodeErrorZ in the error state.
-pub extern "C" fn CResult_ReplyChannelRangeDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_ReplyChannelRangeDecodeErrorZ {
-       CResult_ReplyChannelRangeDecodeErrorZ {
-               contents: CResult_ReplyChannelRangeDecodeErrorZPtr {
+/// Creates a new CResult_ShutdownDecodeErrorZ in the error state.
+pub extern "C" fn CResult_ShutdownDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_ShutdownDecodeErrorZ {
+       CResult_ShutdownDecodeErrorZ {
+               contents: CResult_ShutdownDecodeErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_ReplyChannelRangeDecodeErrorZ.
-pub extern "C" fn CResult_ReplyChannelRangeDecodeErrorZ_free(_res: CResult_ReplyChannelRangeDecodeErrorZ) { }
-impl Drop for CResult_ReplyChannelRangeDecodeErrorZ {
+/// Frees any resources used by the CResult_ShutdownDecodeErrorZ.
+pub extern "C" fn CResult_ShutdownDecodeErrorZ_free(_res: CResult_ShutdownDecodeErrorZ) { }
+impl Drop for CResult_ShutdownDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -8906,16 +9185,16 @@ impl Drop for CResult_ReplyChannelRangeDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::ReplyChannelRange, crate::lightning::ln::msgs::DecodeError>> for CResult_ReplyChannelRangeDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::ReplyChannelRange, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::Shutdown, crate::lightning::ln::msgs::DecodeError>> for CResult_ShutdownDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::Shutdown, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_ReplyChannelRangeDecodeErrorZPtr { result }
+                       CResult_ShutdownDecodeErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_ReplyChannelRangeDecodeErrorZPtr { err }
+                       CResult_ShutdownDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -8923,68 +9202,68 @@ impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::ReplyChannelR
                }
        }
 }
-impl Clone for CResult_ReplyChannelRangeDecodeErrorZ {
+impl Clone for CResult_ShutdownDecodeErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_ReplyChannelRangeDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::ReplyChannelRange>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_ShutdownDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::Shutdown>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_ReplyChannelRangeDecodeErrorZPtr {
+                       Self { result_ok: false, contents: CResult_ShutdownDecodeErrorZPtr {
                                err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_ReplyChannelRangeDecodeErrorZ which has the same data as `orig`
+/// Creates a new CResult_ShutdownDecodeErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_ReplyChannelRangeDecodeErrorZ_clone(orig: &CResult_ReplyChannelRangeDecodeErrorZ) -> CResult_ReplyChannelRangeDecodeErrorZ { orig.clone() }
+pub extern "C" fn CResult_ShutdownDecodeErrorZ_clone(orig: &CResult_ShutdownDecodeErrorZ) -> CResult_ShutdownDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_GossipTimestampFilterDecodeErrorZ
-pub union CResult_GossipTimestampFilterDecodeErrorZPtr {
+/// The contents of CResult_UpdateFailHTLCDecodeErrorZ
+pub union CResult_UpdateFailHTLCDecodeErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::ln::msgs::GossipTimestampFilter,
+       pub result: *mut crate::lightning::ln::msgs::UpdateFailHTLC,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
        pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// 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_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`.
-pub struct CResult_GossipTimestampFilterDecodeErrorZ {
-       /// The contents of this CResult_GossipTimestampFilterDecodeErrorZ, accessible via either
+pub struct CResult_UpdateFailHTLCDecodeErrorZ {
+       /// The contents of this CResult_UpdateFailHTLCDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_GossipTimestampFilterDecodeErrorZPtr,
-       /// Whether this CResult_GossipTimestampFilterDecodeErrorZ represents a success state.
+       pub contents: CResult_UpdateFailHTLCDecodeErrorZPtr,
+       /// Whether this CResult_UpdateFailHTLCDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_GossipTimestampFilterDecodeErrorZ in the success state.
-pub extern "C" fn CResult_GossipTimestampFilterDecodeErrorZ_ok(o: crate::lightning::ln::msgs::GossipTimestampFilter) -> CResult_GossipTimestampFilterDecodeErrorZ {
-       CResult_GossipTimestampFilterDecodeErrorZ {
-               contents: CResult_GossipTimestampFilterDecodeErrorZPtr {
+/// Creates a new CResult_UpdateFailHTLCDecodeErrorZ in the success state.
+pub extern "C" fn CResult_UpdateFailHTLCDecodeErrorZ_ok(o: crate::lightning::ln::msgs::UpdateFailHTLC) -> CResult_UpdateFailHTLCDecodeErrorZ {
+       CResult_UpdateFailHTLCDecodeErrorZ {
+               contents: CResult_UpdateFailHTLCDecodeErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_GossipTimestampFilterDecodeErrorZ in the error state.
-pub extern "C" fn CResult_GossipTimestampFilterDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_GossipTimestampFilterDecodeErrorZ {
-       CResult_GossipTimestampFilterDecodeErrorZ {
-               contents: CResult_GossipTimestampFilterDecodeErrorZPtr {
+/// Creates a new CResult_UpdateFailHTLCDecodeErrorZ in the error state.
+pub extern "C" fn CResult_UpdateFailHTLCDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_UpdateFailHTLCDecodeErrorZ {
+       CResult_UpdateFailHTLCDecodeErrorZ {
+               contents: CResult_UpdateFailHTLCDecodeErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_GossipTimestampFilterDecodeErrorZ.
-pub extern "C" fn CResult_GossipTimestampFilterDecodeErrorZ_free(_res: CResult_GossipTimestampFilterDecodeErrorZ) { }
-impl Drop for CResult_GossipTimestampFilterDecodeErrorZ {
+/// Frees any resources used by the CResult_UpdateFailHTLCDecodeErrorZ.
+pub extern "C" fn CResult_UpdateFailHTLCDecodeErrorZ_free(_res: CResult_UpdateFailHTLCDecodeErrorZ) { }
+impl Drop for CResult_UpdateFailHTLCDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -8997,16 +9276,16 @@ impl Drop for CResult_GossipTimestampFilterDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::GossipTimestampFilter, crate::lightning::ln::msgs::DecodeError>> for CResult_GossipTimestampFilterDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::GossipTimestampFilter, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::UpdateFailHTLC, crate::lightning::ln::msgs::DecodeError>> for CResult_UpdateFailHTLCDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::UpdateFailHTLC, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_GossipTimestampFilterDecodeErrorZPtr { result }
+                       CResult_UpdateFailHTLCDecodeErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_GossipTimestampFilterDecodeErrorZPtr { err }
+                       CResult_UpdateFailHTLCDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -9014,68 +9293,68 @@ impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::GossipTimesta
                }
        }
 }
-impl Clone for CResult_GossipTimestampFilterDecodeErrorZ {
+impl Clone for CResult_UpdateFailHTLCDecodeErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_GossipTimestampFilterDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::GossipTimestampFilter>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_UpdateFailHTLCDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::UpdateFailHTLC>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_GossipTimestampFilterDecodeErrorZPtr {
+                       Self { result_ok: false, contents: CResult_UpdateFailHTLCDecodeErrorZPtr {
                                err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_GossipTimestampFilterDecodeErrorZ which has the same data as `orig`
+/// Creates a new CResult_UpdateFailHTLCDecodeErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_GossipTimestampFilterDecodeErrorZ_clone(orig: &CResult_GossipTimestampFilterDecodeErrorZ) -> CResult_GossipTimestampFilterDecodeErrorZ { orig.clone() }
+pub extern "C" fn CResult_UpdateFailHTLCDecodeErrorZ_clone(orig: &CResult_UpdateFailHTLCDecodeErrorZ) -> CResult_UpdateFailHTLCDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_InvoiceSignOrCreationErrorZ
-pub union CResult_InvoiceSignOrCreationErrorZPtr {
+/// The contents of CResult_UpdateFailMalformedHTLCDecodeErrorZ
+pub union CResult_UpdateFailMalformedHTLCDecodeErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning_invoice::Invoice,
+       pub result: *mut crate::lightning::ln::msgs::UpdateFailMalformedHTLC,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::lightning_invoice::SignOrCreationError,
+       pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// A CResult_InvoiceSignOrCreationErrorZ represents the result of a fallible operation,
-/// containing a crate::lightning_invoice::Invoice on success and a crate::lightning_invoice::SignOrCreationError 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`.
-pub struct CResult_InvoiceSignOrCreationErrorZ {
-       /// The contents of this CResult_InvoiceSignOrCreationErrorZ, accessible via either
+pub struct CResult_UpdateFailMalformedHTLCDecodeErrorZ {
+       /// The contents of this CResult_UpdateFailMalformedHTLCDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_InvoiceSignOrCreationErrorZPtr,
-       /// Whether this CResult_InvoiceSignOrCreationErrorZ represents a success state.
+       pub contents: CResult_UpdateFailMalformedHTLCDecodeErrorZPtr,
+       /// Whether this CResult_UpdateFailMalformedHTLCDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_InvoiceSignOrCreationErrorZ in the success state.
-pub extern "C" fn CResult_InvoiceSignOrCreationErrorZ_ok(o: crate::lightning_invoice::Invoice) -> CResult_InvoiceSignOrCreationErrorZ {
-       CResult_InvoiceSignOrCreationErrorZ {
-               contents: CResult_InvoiceSignOrCreationErrorZPtr {
+/// Creates a new CResult_UpdateFailMalformedHTLCDecodeErrorZ in the success state.
+pub extern "C" fn CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o: crate::lightning::ln::msgs::UpdateFailMalformedHTLC) -> CResult_UpdateFailMalformedHTLCDecodeErrorZ {
+       CResult_UpdateFailMalformedHTLCDecodeErrorZ {
+               contents: CResult_UpdateFailMalformedHTLCDecodeErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_InvoiceSignOrCreationErrorZ in the error state.
-pub extern "C" fn CResult_InvoiceSignOrCreationErrorZ_err(e: crate::lightning_invoice::SignOrCreationError) -> CResult_InvoiceSignOrCreationErrorZ {
-       CResult_InvoiceSignOrCreationErrorZ {
-               contents: CResult_InvoiceSignOrCreationErrorZPtr {
+/// Creates a new CResult_UpdateFailMalformedHTLCDecodeErrorZ in the error state.
+pub extern "C" fn CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_UpdateFailMalformedHTLCDecodeErrorZ {
+       CResult_UpdateFailMalformedHTLCDecodeErrorZ {
+               contents: CResult_UpdateFailMalformedHTLCDecodeErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_InvoiceSignOrCreationErrorZ.
-pub extern "C" fn CResult_InvoiceSignOrCreationErrorZ_free(_res: CResult_InvoiceSignOrCreationErrorZ) { }
-impl Drop for CResult_InvoiceSignOrCreationErrorZ {
+/// Frees any resources used by the CResult_UpdateFailMalformedHTLCDecodeErrorZ.
+pub extern "C" fn CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res: CResult_UpdateFailMalformedHTLCDecodeErrorZ) { }
+impl Drop for CResult_UpdateFailMalformedHTLCDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -9088,16 +9367,16 @@ impl Drop for CResult_InvoiceSignOrCreationErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning_invoice::Invoice, crate::lightning_invoice::SignOrCreationError>> for CResult_InvoiceSignOrCreationErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning_invoice::Invoice, crate::lightning_invoice::SignOrCreationError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::UpdateFailMalformedHTLC, crate::lightning::ln::msgs::DecodeError>> for CResult_UpdateFailMalformedHTLCDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::UpdateFailMalformedHTLC, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_InvoiceSignOrCreationErrorZPtr { result }
+                       CResult_UpdateFailMalformedHTLCDecodeErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_InvoiceSignOrCreationErrorZPtr { err }
+                       CResult_UpdateFailMalformedHTLCDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -9105,68 +9384,68 @@ impl From<crate::c_types::CResultTempl<crate::lightning_invoice::Invoice, crate:
                }
        }
 }
-impl Clone for CResult_InvoiceSignOrCreationErrorZ {
+impl Clone for CResult_UpdateFailMalformedHTLCDecodeErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_InvoiceSignOrCreationErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning_invoice::Invoice>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_UpdateFailMalformedHTLCDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::UpdateFailMalformedHTLC>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_InvoiceSignOrCreationErrorZPtr {
-                               err: Box::into_raw(Box::new(<crate::lightning_invoice::SignOrCreationError>::clone(unsafe { &*self.contents.err })))
+                       Self { result_ok: false, contents: CResult_UpdateFailMalformedHTLCDecodeErrorZPtr {
+                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_InvoiceSignOrCreationErrorZ which has the same data as `orig`
+/// Creates a new CResult_UpdateFailMalformedHTLCDecodeErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_InvoiceSignOrCreationErrorZ_clone(orig: &CResult_InvoiceSignOrCreationErrorZ) -> CResult_InvoiceSignOrCreationErrorZ { orig.clone() }
+pub extern "C" fn CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig: &CResult_UpdateFailMalformedHTLCDecodeErrorZ) -> CResult_UpdateFailMalformedHTLCDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_DelayedPaymentOutputDescriptorDecodeErrorZ
-pub union CResult_DelayedPaymentOutputDescriptorDecodeErrorZPtr {
+/// The contents of CResult_UpdateFeeDecodeErrorZ
+pub union CResult_UpdateFeeDecodeErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::chain::keysinterface::DelayedPaymentOutputDescriptor,
+       pub result: *mut crate::lightning::ln::msgs::UpdateFee,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
        pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// A CResult_DelayedPaymentOutputDescriptorDecodeErrorZ represents the result of a fallible operation,
-/// containing a crate::lightning::chain::keysinterface::DelayedPaymentOutputDescriptor 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`.
-pub struct CResult_DelayedPaymentOutputDescriptorDecodeErrorZ {
-       /// The contents of this CResult_DelayedPaymentOutputDescriptorDecodeErrorZ, accessible via either
+pub struct CResult_UpdateFeeDecodeErrorZ {
+       /// The contents of this CResult_UpdateFeeDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_DelayedPaymentOutputDescriptorDecodeErrorZPtr,
-       /// Whether this CResult_DelayedPaymentOutputDescriptorDecodeErrorZ represents a success state.
+       pub contents: CResult_UpdateFeeDecodeErrorZPtr,
+       /// Whether this CResult_UpdateFeeDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_DelayedPaymentOutputDescriptorDecodeErrorZ in the success state.
-pub extern "C" fn CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o: crate::lightning::chain::keysinterface::DelayedPaymentOutputDescriptor) -> CResult_DelayedPaymentOutputDescriptorDecodeErrorZ {
-       CResult_DelayedPaymentOutputDescriptorDecodeErrorZ {
-               contents: CResult_DelayedPaymentOutputDescriptorDecodeErrorZPtr {
+/// Creates a new CResult_UpdateFeeDecodeErrorZ in the success state.
+pub extern "C" fn CResult_UpdateFeeDecodeErrorZ_ok(o: crate::lightning::ln::msgs::UpdateFee) -> CResult_UpdateFeeDecodeErrorZ {
+       CResult_UpdateFeeDecodeErrorZ {
+               contents: CResult_UpdateFeeDecodeErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_DelayedPaymentOutputDescriptorDecodeErrorZ in the error state.
-pub extern "C" fn CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_DelayedPaymentOutputDescriptorDecodeErrorZ {
-       CResult_DelayedPaymentOutputDescriptorDecodeErrorZ {
-               contents: CResult_DelayedPaymentOutputDescriptorDecodeErrorZPtr {
+/// Creates a new CResult_UpdateFeeDecodeErrorZ in the error state.
+pub extern "C" fn CResult_UpdateFeeDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_UpdateFeeDecodeErrorZ {
+       CResult_UpdateFeeDecodeErrorZ {
+               contents: CResult_UpdateFeeDecodeErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_DelayedPaymentOutputDescriptorDecodeErrorZ.
-pub extern "C" fn CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res: CResult_DelayedPaymentOutputDescriptorDecodeErrorZ) { }
-impl Drop for CResult_DelayedPaymentOutputDescriptorDecodeErrorZ {
+/// Frees any resources used by the CResult_UpdateFeeDecodeErrorZ.
+pub extern "C" fn CResult_UpdateFeeDecodeErrorZ_free(_res: CResult_UpdateFeeDecodeErrorZ) { }
+impl Drop for CResult_UpdateFeeDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -9179,16 +9458,16 @@ impl Drop for CResult_DelayedPaymentOutputDescriptorDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::chain::keysinterface::DelayedPaymentOutputDescriptor, crate::lightning::ln::msgs::DecodeError>> for CResult_DelayedPaymentOutputDescriptorDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::chain::keysinterface::DelayedPaymentOutputDescriptor, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::UpdateFee, crate::lightning::ln::msgs::DecodeError>> for CResult_UpdateFeeDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::UpdateFee, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_DelayedPaymentOutputDescriptorDecodeErrorZPtr { result }
+                       CResult_UpdateFeeDecodeErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_DelayedPaymentOutputDescriptorDecodeErrorZPtr { err }
+                       CResult_UpdateFeeDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -9196,68 +9475,68 @@ impl From<crate::c_types::CResultTempl<crate::lightning::chain::keysinterface::D
                }
        }
 }
-impl Clone for CResult_DelayedPaymentOutputDescriptorDecodeErrorZ {
+impl Clone for CResult_UpdateFeeDecodeErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_DelayedPaymentOutputDescriptorDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::chain::keysinterface::DelayedPaymentOutputDescriptor>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_UpdateFeeDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::UpdateFee>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_DelayedPaymentOutputDescriptorDecodeErrorZPtr {
+                       Self { result_ok: false, contents: CResult_UpdateFeeDecodeErrorZPtr {
                                err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_DelayedPaymentOutputDescriptorDecodeErrorZ which has the same data as `orig`
+/// Creates a new CResult_UpdateFeeDecodeErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig: &CResult_DelayedPaymentOutputDescriptorDecodeErrorZ) -> CResult_DelayedPaymentOutputDescriptorDecodeErrorZ { orig.clone() }
+pub extern "C" fn CResult_UpdateFeeDecodeErrorZ_clone(orig: &CResult_UpdateFeeDecodeErrorZ) -> CResult_UpdateFeeDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_StaticPaymentOutputDescriptorDecodeErrorZ
-pub union CResult_StaticPaymentOutputDescriptorDecodeErrorZPtr {
+/// The contents of CResult_UpdateFulfillHTLCDecodeErrorZ
+pub union CResult_UpdateFulfillHTLCDecodeErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::chain::keysinterface::StaticPaymentOutputDescriptor,
+       pub result: *mut crate::lightning::ln::msgs::UpdateFulfillHTLC,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
        pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// A CResult_StaticPaymentOutputDescriptorDecodeErrorZ represents the result of a fallible operation,
-/// containing a crate::lightning::chain::keysinterface::StaticPaymentOutputDescriptor 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`.
-pub struct CResult_StaticPaymentOutputDescriptorDecodeErrorZ {
-       /// The contents of this CResult_StaticPaymentOutputDescriptorDecodeErrorZ, accessible via either
+pub struct CResult_UpdateFulfillHTLCDecodeErrorZ {
+       /// The contents of this CResult_UpdateFulfillHTLCDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_StaticPaymentOutputDescriptorDecodeErrorZPtr,
-       /// Whether this CResult_StaticPaymentOutputDescriptorDecodeErrorZ represents a success state.
+       pub contents: CResult_UpdateFulfillHTLCDecodeErrorZPtr,
+       /// Whether this CResult_UpdateFulfillHTLCDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_StaticPaymentOutputDescriptorDecodeErrorZ in the success state.
-pub extern "C" fn CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o: crate::lightning::chain::keysinterface::StaticPaymentOutputDescriptor) -> CResult_StaticPaymentOutputDescriptorDecodeErrorZ {
-       CResult_StaticPaymentOutputDescriptorDecodeErrorZ {
-               contents: CResult_StaticPaymentOutputDescriptorDecodeErrorZPtr {
+/// Creates a new CResult_UpdateFulfillHTLCDecodeErrorZ in the success state.
+pub extern "C" fn CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o: crate::lightning::ln::msgs::UpdateFulfillHTLC) -> CResult_UpdateFulfillHTLCDecodeErrorZ {
+       CResult_UpdateFulfillHTLCDecodeErrorZ {
+               contents: CResult_UpdateFulfillHTLCDecodeErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_StaticPaymentOutputDescriptorDecodeErrorZ in the error state.
-pub extern "C" fn CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_StaticPaymentOutputDescriptorDecodeErrorZ {
-       CResult_StaticPaymentOutputDescriptorDecodeErrorZ {
-               contents: CResult_StaticPaymentOutputDescriptorDecodeErrorZPtr {
+/// Creates a new CResult_UpdateFulfillHTLCDecodeErrorZ in the error state.
+pub extern "C" fn CResult_UpdateFulfillHTLCDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_UpdateFulfillHTLCDecodeErrorZ {
+       CResult_UpdateFulfillHTLCDecodeErrorZ {
+               contents: CResult_UpdateFulfillHTLCDecodeErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_StaticPaymentOutputDescriptorDecodeErrorZ.
-pub extern "C" fn CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res: CResult_StaticPaymentOutputDescriptorDecodeErrorZ) { }
-impl Drop for CResult_StaticPaymentOutputDescriptorDecodeErrorZ {
+/// Frees any resources used by the CResult_UpdateFulfillHTLCDecodeErrorZ.
+pub extern "C" fn CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res: CResult_UpdateFulfillHTLCDecodeErrorZ) { }
+impl Drop for CResult_UpdateFulfillHTLCDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -9270,16 +9549,16 @@ impl Drop for CResult_StaticPaymentOutputDescriptorDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::chain::keysinterface::StaticPaymentOutputDescriptor, crate::lightning::ln::msgs::DecodeError>> for CResult_StaticPaymentOutputDescriptorDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::chain::keysinterface::StaticPaymentOutputDescriptor, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::UpdateFulfillHTLC, crate::lightning::ln::msgs::DecodeError>> for CResult_UpdateFulfillHTLCDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::UpdateFulfillHTLC, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_StaticPaymentOutputDescriptorDecodeErrorZPtr { result }
+                       CResult_UpdateFulfillHTLCDecodeErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_StaticPaymentOutputDescriptorDecodeErrorZPtr { err }
+                       CResult_UpdateFulfillHTLCDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -9287,68 +9566,68 @@ impl From<crate::c_types::CResultTempl<crate::lightning::chain::keysinterface::S
                }
        }
 }
-impl Clone for CResult_StaticPaymentOutputDescriptorDecodeErrorZ {
+impl Clone for CResult_UpdateFulfillHTLCDecodeErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_StaticPaymentOutputDescriptorDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::chain::keysinterface::StaticPaymentOutputDescriptor>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_UpdateFulfillHTLCDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::UpdateFulfillHTLC>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_StaticPaymentOutputDescriptorDecodeErrorZPtr {
+                       Self { result_ok: false, contents: CResult_UpdateFulfillHTLCDecodeErrorZPtr {
                                err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_StaticPaymentOutputDescriptorDecodeErrorZ which has the same data as `orig`
+/// Creates a new CResult_UpdateFulfillHTLCDecodeErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig: &CResult_StaticPaymentOutputDescriptorDecodeErrorZ) -> CResult_StaticPaymentOutputDescriptorDecodeErrorZ { orig.clone() }
+pub extern "C" fn CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig: &CResult_UpdateFulfillHTLCDecodeErrorZ) -> CResult_UpdateFulfillHTLCDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_SpendableOutputDescriptorDecodeErrorZ
-pub union CResult_SpendableOutputDescriptorDecodeErrorZPtr {
+/// The contents of CResult_UpdateAddHTLCDecodeErrorZ
+pub union CResult_UpdateAddHTLCDecodeErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::chain::keysinterface::SpendableOutputDescriptor,
+       pub result: *mut crate::lightning::ln::msgs::UpdateAddHTLC,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
        pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// 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_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`.
-pub struct CResult_SpendableOutputDescriptorDecodeErrorZ {
-       /// The contents of this CResult_SpendableOutputDescriptorDecodeErrorZ, accessible via either
+pub struct CResult_UpdateAddHTLCDecodeErrorZ {
+       /// The contents of this CResult_UpdateAddHTLCDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_SpendableOutputDescriptorDecodeErrorZPtr,
-       /// Whether this CResult_SpendableOutputDescriptorDecodeErrorZ represents a success state.
+       pub contents: CResult_UpdateAddHTLCDecodeErrorZPtr,
+       /// Whether this CResult_UpdateAddHTLCDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_SpendableOutputDescriptorDecodeErrorZ in the success state.
-pub extern "C" fn CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o: crate::lightning::chain::keysinterface::SpendableOutputDescriptor) -> CResult_SpendableOutputDescriptorDecodeErrorZ {
-       CResult_SpendableOutputDescriptorDecodeErrorZ {
-               contents: CResult_SpendableOutputDescriptorDecodeErrorZPtr {
+/// Creates a new CResult_UpdateAddHTLCDecodeErrorZ in the success state.
+pub extern "C" fn CResult_UpdateAddHTLCDecodeErrorZ_ok(o: crate::lightning::ln::msgs::UpdateAddHTLC) -> CResult_UpdateAddHTLCDecodeErrorZ {
+       CResult_UpdateAddHTLCDecodeErrorZ {
+               contents: CResult_UpdateAddHTLCDecodeErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_SpendableOutputDescriptorDecodeErrorZ in the error state.
-pub extern "C" fn CResult_SpendableOutputDescriptorDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_SpendableOutputDescriptorDecodeErrorZ {
-       CResult_SpendableOutputDescriptorDecodeErrorZ {
-               contents: CResult_SpendableOutputDescriptorDecodeErrorZPtr {
+/// Creates a new CResult_UpdateAddHTLCDecodeErrorZ in the error state.
+pub extern "C" fn CResult_UpdateAddHTLCDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_UpdateAddHTLCDecodeErrorZ {
+       CResult_UpdateAddHTLCDecodeErrorZ {
+               contents: CResult_UpdateAddHTLCDecodeErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_SpendableOutputDescriptorDecodeErrorZ.
-pub extern "C" fn CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res: CResult_SpendableOutputDescriptorDecodeErrorZ) { }
-impl Drop for CResult_SpendableOutputDescriptorDecodeErrorZ {
+/// Frees any resources used by the CResult_UpdateAddHTLCDecodeErrorZ.
+pub extern "C" fn CResult_UpdateAddHTLCDecodeErrorZ_free(_res: CResult_UpdateAddHTLCDecodeErrorZ) { }
+impl Drop for CResult_UpdateAddHTLCDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -9361,16 +9640,16 @@ impl Drop for CResult_SpendableOutputDescriptorDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::chain::keysinterface::SpendableOutputDescriptor, crate::lightning::ln::msgs::DecodeError>> for CResult_SpendableOutputDescriptorDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::chain::keysinterface::SpendableOutputDescriptor, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::UpdateAddHTLC, crate::lightning::ln::msgs::DecodeError>> for CResult_UpdateAddHTLCDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::UpdateAddHTLC, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_SpendableOutputDescriptorDecodeErrorZPtr { result }
+                       CResult_UpdateAddHTLCDecodeErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_SpendableOutputDescriptorDecodeErrorZPtr { err }
+                       CResult_UpdateAddHTLCDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -9378,128 +9657,90 @@ impl From<crate::c_types::CResultTempl<crate::lightning::chain::keysinterface::S
                }
        }
 }
-impl Clone for CResult_SpendableOutputDescriptorDecodeErrorZ {
+impl Clone for CResult_UpdateAddHTLCDecodeErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_SpendableOutputDescriptorDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::chain::keysinterface::SpendableOutputDescriptor>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_UpdateAddHTLCDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::UpdateAddHTLC>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_SpendableOutputDescriptorDecodeErrorZPtr {
+                       Self { result_ok: false, contents: CResult_UpdateAddHTLCDecodeErrorZPtr {
                                err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_SpendableOutputDescriptorDecodeErrorZ which has the same data as `orig`
-/// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig: &CResult_SpendableOutputDescriptorDecodeErrorZ) -> CResult_SpendableOutputDescriptorDecodeErrorZ { orig.clone() }
-#[repr(C)]
-/// A tuple of 2 elements. See the individual fields for the types contained.
-pub struct C2Tuple_SignatureCVec_SignatureZZ {
-       /// The element at position 0
-       pub a: crate::c_types::Signature,
-       /// The element at position 1
-       pub b: crate::c_types::derived::CVec_SignatureZ,
-}
-impl From<(crate::c_types::Signature, crate::c_types::derived::CVec_SignatureZ)> for C2Tuple_SignatureCVec_SignatureZZ {
-       fn from (tup: (crate::c_types::Signature, crate::c_types::derived::CVec_SignatureZ)) -> Self {
-               Self {
-                       a: tup.0,
-                       b: tup.1,
-               }
-       }
-}
-impl C2Tuple_SignatureCVec_SignatureZZ {
-       #[allow(unused)] pub(crate) fn to_rust(mut self) -> (crate::c_types::Signature, crate::c_types::derived::CVec_SignatureZ) {
-               (self.a, self.b)
-       }
-}
-impl Clone for C2Tuple_SignatureCVec_SignatureZZ {
-       fn clone(&self) -> Self {
-               Self {
-                       a: self.a.clone(),
-                       b: self.b.clone(),
-               }
-       }
-}
-#[no_mangle]
-/// Creates a new tuple which has the same data as `orig`
+/// Creates a new CResult_UpdateAddHTLCDecodeErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn C2Tuple_SignatureCVec_SignatureZZ_clone(orig: &C2Tuple_SignatureCVec_SignatureZZ) -> C2Tuple_SignatureCVec_SignatureZZ { orig.clone() }
-/// Creates a new C2Tuple_SignatureCVec_SignatureZZ from the contained elements.
-#[no_mangle]
-pub extern "C" fn C2Tuple_SignatureCVec_SignatureZZ_new(a: crate::c_types::Signature, b: crate::c_types::derived::CVec_SignatureZ) -> C2Tuple_SignatureCVec_SignatureZZ {
-       C2Tuple_SignatureCVec_SignatureZZ { a, b, }
-}
-
-#[no_mangle]
-/// Frees any resources used by the C2Tuple_SignatureCVec_SignatureZZ.
-pub extern "C" fn C2Tuple_SignatureCVec_SignatureZZ_free(_res: C2Tuple_SignatureCVec_SignatureZZ) { }
+pub extern "C" fn CResult_UpdateAddHTLCDecodeErrorZ_clone(orig: &CResult_UpdateAddHTLCDecodeErrorZ) -> CResult_UpdateAddHTLCDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ
-pub union CResult_C2Tuple_SignatureCVec_SignatureZZNoneZPtr {
+/// The contents of CResult_PingDecodeErrorZ
+pub union CResult_PingDecodeErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::c_types::derived::C2Tuple_SignatureCVec_SignatureZZ,
-       /// Note that this value is always NULL, as there are no contents in the Err variant
-       pub err: *mut std::ffi::c_void,
+       pub result: *mut crate::lightning::ln::msgs::Ping,
+       /// A pointer to the contents in the error state.
+       /// Reading from this pointer when `result_ok` is set is undefined.
+       pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// 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_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`.
-pub struct CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ {
-       /// The contents of this CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ, accessible via either
+pub struct CResult_PingDecodeErrorZ {
+       /// The contents of this CResult_PingDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_C2Tuple_SignatureCVec_SignatureZZNoneZPtr,
-       /// Whether this CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ represents a success state.
+       pub contents: CResult_PingDecodeErrorZPtr,
+       /// Whether this CResult_PingDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ in the success state.
-pub extern "C" fn CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o: crate::c_types::derived::C2Tuple_SignatureCVec_SignatureZZ) -> CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ {
-       CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ {
-               contents: CResult_C2Tuple_SignatureCVec_SignatureZZNoneZPtr {
+/// Creates a new CResult_PingDecodeErrorZ in the success state.
+pub extern "C" fn CResult_PingDecodeErrorZ_ok(o: crate::lightning::ln::msgs::Ping) -> CResult_PingDecodeErrorZ {
+       CResult_PingDecodeErrorZ {
+               contents: CResult_PingDecodeErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ in the error state.
-pub extern "C" fn CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err() -> CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ {
-       CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ {
-               contents: CResult_C2Tuple_SignatureCVec_SignatureZZNoneZPtr {
-                       err: std::ptr::null_mut(),
+/// Creates a new CResult_PingDecodeErrorZ in the error state.
+pub extern "C" fn CResult_PingDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_PingDecodeErrorZ {
+       CResult_PingDecodeErrorZ {
+               contents: CResult_PingDecodeErrorZPtr {
+                       err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ.
-pub extern "C" fn CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res: CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ) { }
-impl Drop for CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ {
+/// Frees any resources used by the CResult_PingDecodeErrorZ.
+pub extern "C" fn CResult_PingDecodeErrorZ_free(_res: CResult_PingDecodeErrorZ) { }
+impl Drop for CResult_PingDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
                                let _ = unsafe { Box::from_raw(self.contents.result) };
                        }
                } else {
+                       if unsafe { !(self.contents.err as *mut ()).is_null() } {
+                               let _ = unsafe { Box::from_raw(self.contents.err) };
+                       }
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::c_types::derived::C2Tuple_SignatureCVec_SignatureZZ, ()>> for CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::c_types::derived::C2Tuple_SignatureCVec_SignatureZZ, ()>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::Ping, crate::lightning::ln::msgs::DecodeError>> for CResult_PingDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::Ping, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_C2Tuple_SignatureCVec_SignatureZZNoneZPtr { result }
+                       CResult_PingDecodeErrorZPtr { result }
                } else {
-                       let _ = unsafe { Box::from_raw(o.contents.err) };
-                       o.contents.err = std::ptr::null_mut();
-                       CResult_C2Tuple_SignatureCVec_SignatureZZNoneZPtr { err: std::ptr::null_mut() }
+                       let err = unsafe { o.contents.err };
+                       unsafe { o.contents.err = std::ptr::null_mut(); }
+                       CResult_PingDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -9507,86 +9748,90 @@ impl From<crate::c_types::CResultTempl<crate::c_types::derived::C2Tuple_Signatur
                }
        }
 }
-impl Clone for CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ {
+impl Clone for CResult_PingDecodeErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_C2Tuple_SignatureCVec_SignatureZZNoneZPtr {
-                               result: Box::into_raw(Box::new(<crate::c_types::derived::C2Tuple_SignatureCVec_SignatureZZ>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_PingDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::Ping>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_C2Tuple_SignatureCVec_SignatureZZNoneZPtr {
-                               err: std::ptr::null_mut()
+                       Self { result_ok: false, contents: CResult_PingDecodeErrorZPtr {
+                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ which has the same data as `orig`
+/// Creates a new CResult_PingDecodeErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig: &CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ) -> CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ { orig.clone() }
+pub extern "C" fn CResult_PingDecodeErrorZ_clone(orig: &CResult_PingDecodeErrorZ) -> CResult_PingDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_SignatureNoneZ
-pub union CResult_SignatureNoneZPtr {
+/// The contents of CResult_PongDecodeErrorZ
+pub union CResult_PongDecodeErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::c_types::Signature,
-       /// Note that this value is always NULL, as there are no contents in the Err variant
-       pub err: *mut std::ffi::c_void,
+       pub result: *mut crate::lightning::ln::msgs::Pong,
+       /// A pointer to the contents in the error state.
+       /// Reading from this pointer when `result_ok` is set is undefined.
+       pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// A CResult_SignatureNoneZ represents the result of a fallible operation,
-/// containing a crate::c_types::Signature on success and a () 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`.
-pub struct CResult_SignatureNoneZ {
-       /// The contents of this CResult_SignatureNoneZ, accessible via either
+pub struct CResult_PongDecodeErrorZ {
+       /// The contents of this CResult_PongDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_SignatureNoneZPtr,
-       /// Whether this CResult_SignatureNoneZ represents a success state.
+       pub contents: CResult_PongDecodeErrorZPtr,
+       /// Whether this CResult_PongDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_SignatureNoneZ in the success state.
-pub extern "C" fn CResult_SignatureNoneZ_ok(o: crate::c_types::Signature) -> CResult_SignatureNoneZ {
-       CResult_SignatureNoneZ {
-               contents: CResult_SignatureNoneZPtr {
+/// Creates a new CResult_PongDecodeErrorZ in the success state.
+pub extern "C" fn CResult_PongDecodeErrorZ_ok(o: crate::lightning::ln::msgs::Pong) -> CResult_PongDecodeErrorZ {
+       CResult_PongDecodeErrorZ {
+               contents: CResult_PongDecodeErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_SignatureNoneZ in the error state.
-pub extern "C" fn CResult_SignatureNoneZ_err() -> CResult_SignatureNoneZ {
-       CResult_SignatureNoneZ {
-               contents: CResult_SignatureNoneZPtr {
-                       err: std::ptr::null_mut(),
+/// Creates a new CResult_PongDecodeErrorZ in the error state.
+pub extern "C" fn CResult_PongDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_PongDecodeErrorZ {
+       CResult_PongDecodeErrorZ {
+               contents: CResult_PongDecodeErrorZPtr {
+                       err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_SignatureNoneZ.
-pub extern "C" fn CResult_SignatureNoneZ_free(_res: CResult_SignatureNoneZ) { }
-impl Drop for CResult_SignatureNoneZ {
+/// Frees any resources used by the CResult_PongDecodeErrorZ.
+pub extern "C" fn CResult_PongDecodeErrorZ_free(_res: CResult_PongDecodeErrorZ) { }
+impl Drop for CResult_PongDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
                                let _ = unsafe { Box::from_raw(self.contents.result) };
                        }
                } else {
+                       if unsafe { !(self.contents.err as *mut ()).is_null() } {
+                               let _ = unsafe { Box::from_raw(self.contents.err) };
+                       }
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::c_types::Signature, ()>> for CResult_SignatureNoneZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::c_types::Signature, ()>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::Pong, crate::lightning::ln::msgs::DecodeError>> for CResult_PongDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::Pong, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_SignatureNoneZPtr { result }
+                       CResult_PongDecodeErrorZPtr { result }
                } else {
-                       let _ = unsafe { Box::from_raw(o.contents.err) };
-                       o.contents.err = std::ptr::null_mut();
-                       CResult_SignatureNoneZPtr { err: std::ptr::null_mut() }
+                       let err = unsafe { o.contents.err };
+                       unsafe { o.contents.err = std::ptr::null_mut(); }
+                       CResult_PongDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -9594,68 +9839,68 @@ impl From<crate::c_types::CResultTempl<crate::c_types::Signature, ()>> for CResu
                }
        }
 }
-impl Clone for CResult_SignatureNoneZ {
+impl Clone for CResult_PongDecodeErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_SignatureNoneZPtr {
-                               result: Box::into_raw(Box::new(<crate::c_types::Signature>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_PongDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::Pong>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_SignatureNoneZPtr {
-                               err: std::ptr::null_mut()
+                       Self { result_ok: false, contents: CResult_PongDecodeErrorZPtr {
+                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_SignatureNoneZ which has the same data as `orig`
+/// Creates a new CResult_PongDecodeErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_SignatureNoneZ_clone(orig: &CResult_SignatureNoneZ) -> CResult_SignatureNoneZ { orig.clone() }
+pub extern "C" fn CResult_PongDecodeErrorZ_clone(orig: &CResult_PongDecodeErrorZ) -> CResult_PongDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_SignDecodeErrorZ
-pub union CResult_SignDecodeErrorZPtr {
+/// The contents of CResult_UnsignedChannelAnnouncementDecodeErrorZ
+pub union CResult_UnsignedChannelAnnouncementDecodeErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::chain::keysinterface::Sign,
+       pub result: *mut crate::lightning::ln::msgs::UnsignedChannelAnnouncement,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
        pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// 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`.
-pub struct CResult_SignDecodeErrorZ {
-       /// The contents of this CResult_SignDecodeErrorZ, accessible via either
+pub struct CResult_UnsignedChannelAnnouncementDecodeErrorZ {
+       /// The contents of this CResult_UnsignedChannelAnnouncementDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_SignDecodeErrorZPtr,
-       /// Whether this CResult_SignDecodeErrorZ represents a success state.
+       pub contents: CResult_UnsignedChannelAnnouncementDecodeErrorZPtr,
+       /// Whether this CResult_UnsignedChannelAnnouncementDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_SignDecodeErrorZ in the success state.
-pub extern "C" fn CResult_SignDecodeErrorZ_ok(o: crate::lightning::chain::keysinterface::Sign) -> CResult_SignDecodeErrorZ {
-       CResult_SignDecodeErrorZ {
-               contents: CResult_SignDecodeErrorZPtr {
+/// Creates a new CResult_UnsignedChannelAnnouncementDecodeErrorZ in the success state.
+pub extern "C" fn CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o: crate::lightning::ln::msgs::UnsignedChannelAnnouncement) -> CResult_UnsignedChannelAnnouncementDecodeErrorZ {
+       CResult_UnsignedChannelAnnouncementDecodeErrorZ {
+               contents: CResult_UnsignedChannelAnnouncementDecodeErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_SignDecodeErrorZ in the error state.
-pub extern "C" fn CResult_SignDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_SignDecodeErrorZ {
-       CResult_SignDecodeErrorZ {
-               contents: CResult_SignDecodeErrorZPtr {
+/// Creates a new CResult_UnsignedChannelAnnouncementDecodeErrorZ in the error state.
+pub extern "C" fn CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_UnsignedChannelAnnouncementDecodeErrorZ {
+       CResult_UnsignedChannelAnnouncementDecodeErrorZ {
+               contents: CResult_UnsignedChannelAnnouncementDecodeErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_SignDecodeErrorZ.
-pub extern "C" fn CResult_SignDecodeErrorZ_free(_res: CResult_SignDecodeErrorZ) { }
-impl Drop for CResult_SignDecodeErrorZ {
+/// Frees any resources used by the CResult_UnsignedChannelAnnouncementDecodeErrorZ.
+pub extern "C" fn CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res: CResult_UnsignedChannelAnnouncementDecodeErrorZ) { }
+impl Drop for CResult_UnsignedChannelAnnouncementDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -9668,16 +9913,16 @@ impl Drop for CResult_SignDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::chain::keysinterface::Sign, crate::lightning::ln::msgs::DecodeError>> for CResult_SignDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::chain::keysinterface::Sign, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::UnsignedChannelAnnouncement, crate::lightning::ln::msgs::DecodeError>> for CResult_UnsignedChannelAnnouncementDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::UnsignedChannelAnnouncement, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_SignDecodeErrorZPtr { result }
+                       CResult_UnsignedChannelAnnouncementDecodeErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_SignDecodeErrorZPtr { err }
+                       CResult_UnsignedChannelAnnouncementDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -9685,86 +9930,90 @@ impl From<crate::c_types::CResultTempl<crate::lightning::chain::keysinterface::S
                }
        }
 }
-impl Clone for CResult_SignDecodeErrorZ {
+impl Clone for CResult_UnsignedChannelAnnouncementDecodeErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_SignDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::chain::keysinterface::Sign>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_UnsignedChannelAnnouncementDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::UnsignedChannelAnnouncement>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_SignDecodeErrorZPtr {
+                       Self { result_ok: false, contents: CResult_UnsignedChannelAnnouncementDecodeErrorZPtr {
                                err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_SignDecodeErrorZ which has the same data as `orig`
+/// Creates a new CResult_UnsignedChannelAnnouncementDecodeErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_SignDecodeErrorZ_clone(orig: &CResult_SignDecodeErrorZ) -> CResult_SignDecodeErrorZ { orig.clone() }
+pub extern "C" fn CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig: &CResult_UnsignedChannelAnnouncementDecodeErrorZ) -> CResult_UnsignedChannelAnnouncementDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_RecoverableSignatureNoneZ
-pub union CResult_RecoverableSignatureNoneZPtr {
+/// The contents of CResult_ChannelAnnouncementDecodeErrorZ
+pub union CResult_ChannelAnnouncementDecodeErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::c_types::RecoverableSignature,
-       /// Note that this value is always NULL, as there are no contents in the Err variant
-       pub err: *mut std::ffi::c_void,
+       pub result: *mut crate::lightning::ln::msgs::ChannelAnnouncement,
+       /// A pointer to the contents in the error state.
+       /// Reading from this pointer when `result_ok` is set is undefined.
+       pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// A CResult_RecoverableSignatureNoneZ represents the result of a fallible operation,
-/// containing a crate::c_types::RecoverableSignature 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`.
-pub struct CResult_RecoverableSignatureNoneZ {
-       /// The contents of this CResult_RecoverableSignatureNoneZ, accessible via either
+pub struct CResult_ChannelAnnouncementDecodeErrorZ {
+       /// The contents of this CResult_ChannelAnnouncementDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_RecoverableSignatureNoneZPtr,
-       /// Whether this CResult_RecoverableSignatureNoneZ represents a success state.
+       pub contents: CResult_ChannelAnnouncementDecodeErrorZPtr,
+       /// Whether this CResult_ChannelAnnouncementDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_RecoverableSignatureNoneZ in the success state.
-pub extern "C" fn CResult_RecoverableSignatureNoneZ_ok(o: crate::c_types::RecoverableSignature) -> CResult_RecoverableSignatureNoneZ {
-       CResult_RecoverableSignatureNoneZ {
-               contents: CResult_RecoverableSignatureNoneZPtr {
+/// Creates a new CResult_ChannelAnnouncementDecodeErrorZ in the success state.
+pub extern "C" fn CResult_ChannelAnnouncementDecodeErrorZ_ok(o: crate::lightning::ln::msgs::ChannelAnnouncement) -> CResult_ChannelAnnouncementDecodeErrorZ {
+       CResult_ChannelAnnouncementDecodeErrorZ {
+               contents: CResult_ChannelAnnouncementDecodeErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_RecoverableSignatureNoneZ in the error state.
-pub extern "C" fn CResult_RecoverableSignatureNoneZ_err() -> CResult_RecoverableSignatureNoneZ {
-       CResult_RecoverableSignatureNoneZ {
-               contents: CResult_RecoverableSignatureNoneZPtr {
-                       err: std::ptr::null_mut(),
+/// Creates a new CResult_ChannelAnnouncementDecodeErrorZ in the error state.
+pub extern "C" fn CResult_ChannelAnnouncementDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_ChannelAnnouncementDecodeErrorZ {
+       CResult_ChannelAnnouncementDecodeErrorZ {
+               contents: CResult_ChannelAnnouncementDecodeErrorZPtr {
+                       err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_RecoverableSignatureNoneZ.
-pub extern "C" fn CResult_RecoverableSignatureNoneZ_free(_res: CResult_RecoverableSignatureNoneZ) { }
-impl Drop for CResult_RecoverableSignatureNoneZ {
+/// Frees any resources used by the CResult_ChannelAnnouncementDecodeErrorZ.
+pub extern "C" fn CResult_ChannelAnnouncementDecodeErrorZ_free(_res: CResult_ChannelAnnouncementDecodeErrorZ) { }
+impl Drop for CResult_ChannelAnnouncementDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
                                let _ = unsafe { Box::from_raw(self.contents.result) };
                        }
                } else {
+                       if unsafe { !(self.contents.err as *mut ()).is_null() } {
+                               let _ = unsafe { Box::from_raw(self.contents.err) };
+                       }
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::c_types::RecoverableSignature, ()>> for CResult_RecoverableSignatureNoneZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::c_types::RecoverableSignature, ()>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::ChannelAnnouncement, crate::lightning::ln::msgs::DecodeError>> for CResult_ChannelAnnouncementDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::ChannelAnnouncement, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_RecoverableSignatureNoneZPtr { result }
+                       CResult_ChannelAnnouncementDecodeErrorZPtr { result }
                } else {
-                       let _ = unsafe { Box::from_raw(o.contents.err) };
-                       o.contents.err = std::ptr::null_mut();
-                       CResult_RecoverableSignatureNoneZPtr { err: std::ptr::null_mut() }
+                       let err = unsafe { o.contents.err };
+                       unsafe { o.contents.err = std::ptr::null_mut(); }
+                       CResult_ChannelAnnouncementDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -9772,132 +10021,181 @@ impl From<crate::c_types::CResultTempl<crate::c_types::RecoverableSignature, ()>
                }
        }
 }
-impl Clone for CResult_RecoverableSignatureNoneZ {
+impl Clone for CResult_ChannelAnnouncementDecodeErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_RecoverableSignatureNoneZPtr {
-                               result: Box::into_raw(Box::new(<crate::c_types::RecoverableSignature>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_ChannelAnnouncementDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::ChannelAnnouncement>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_RecoverableSignatureNoneZPtr {
-                               err: std::ptr::null_mut()
+                       Self { result_ok: false, contents: CResult_ChannelAnnouncementDecodeErrorZPtr {
+                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_RecoverableSignatureNoneZ which has the same data as `orig`
+/// Creates a new CResult_ChannelAnnouncementDecodeErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_RecoverableSignatureNoneZ_clone(orig: &CResult_RecoverableSignatureNoneZ) -> CResult_RecoverableSignatureNoneZ { orig.clone() }
+pub extern "C" fn CResult_ChannelAnnouncementDecodeErrorZ_clone(orig: &CResult_ChannelAnnouncementDecodeErrorZ) -> CResult_ChannelAnnouncementDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// A dynamically-allocated array of crate::c_types::derived::CVec_u8Zs of arbitrary size.
-/// This corresponds to std::vector in C++
-pub struct CVec_CVec_u8ZZ {
-       /// The elements in the array.
-       /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
-       pub data: *mut crate::c_types::derived::CVec_u8Z,
-       /// The number of elements pointed to by `data`.
-       pub datalen: usize
+/// The contents of CResult_UnsignedChannelUpdateDecodeErrorZ
+pub union CResult_UnsignedChannelUpdateDecodeErrorZPtr {
+       /// A pointer to the contents in the success state.
+       /// Reading from this pointer when `result_ok` is not set is undefined.
+       pub result: *mut crate::lightning::ln::msgs::UnsignedChannelUpdate,
+       /// A pointer to the contents in the error state.
+       /// Reading from this pointer when `result_ok` is set is undefined.
+       pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
-impl CVec_CVec_u8ZZ {
-       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::c_types::derived::CVec_u8Z> {
-               if self.datalen == 0 { return Vec::new(); }
-               let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
-               self.data = std::ptr::null_mut();
-               self.datalen = 0;
-               ret
+#[repr(C)]
+/// 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`.
+pub struct CResult_UnsignedChannelUpdateDecodeErrorZ {
+       /// The contents of this CResult_UnsignedChannelUpdateDecodeErrorZ, accessible via either
+       /// `err` or `result` depending on the state of `result_ok`.
+       pub contents: CResult_UnsignedChannelUpdateDecodeErrorZPtr,
+       /// Whether this CResult_UnsignedChannelUpdateDecodeErrorZ represents a success state.
+       pub result_ok: bool,
+}
+#[no_mangle]
+/// Creates a new CResult_UnsignedChannelUpdateDecodeErrorZ in the success state.
+pub extern "C" fn CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o: crate::lightning::ln::msgs::UnsignedChannelUpdate) -> CResult_UnsignedChannelUpdateDecodeErrorZ {
+       CResult_UnsignedChannelUpdateDecodeErrorZ {
+               contents: CResult_UnsignedChannelUpdateDecodeErrorZPtr {
+                       result: Box::into_raw(Box::new(o)),
+               },
+               result_ok: true,
        }
-       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::c_types::derived::CVec_u8Z] {
-               unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
+}
+#[no_mangle]
+/// Creates a new CResult_UnsignedChannelUpdateDecodeErrorZ in the error state.
+pub extern "C" fn CResult_UnsignedChannelUpdateDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_UnsignedChannelUpdateDecodeErrorZ {
+       CResult_UnsignedChannelUpdateDecodeErrorZ {
+               contents: CResult_UnsignedChannelUpdateDecodeErrorZPtr {
+                       err: Box::into_raw(Box::new(e)),
+               },
+               result_ok: false,
        }
 }
-impl From<Vec<crate::c_types::derived::CVec_u8Z>> for CVec_CVec_u8ZZ {
-       fn from(v: Vec<crate::c_types::derived::CVec_u8Z>) -> Self {
-               let datalen = v.len();
-               let data = Box::into_raw(v.into_boxed_slice());
-               Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
+#[no_mangle]
+/// Frees any resources used by the CResult_UnsignedChannelUpdateDecodeErrorZ.
+pub extern "C" fn CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res: CResult_UnsignedChannelUpdateDecodeErrorZ) { }
+impl Drop for CResult_UnsignedChannelUpdateDecodeErrorZ {
+       fn drop(&mut self) {
+               if self.result_ok {
+                       if unsafe { !(self.contents.result as *mut ()).is_null() } {
+                               let _ = unsafe { Box::from_raw(self.contents.result) };
+                       }
+               } else {
+                       if unsafe { !(self.contents.err as *mut ()).is_null() } {
+                               let _ = unsafe { Box::from_raw(self.contents.err) };
+                       }
+               }
        }
 }
-#[no_mangle]
-/// Frees the buffer pointed to by `data` if `datalen` is non-0.
-pub extern "C" fn CVec_CVec_u8ZZ_free(_res: CVec_CVec_u8ZZ) { }
-impl Drop for CVec_CVec_u8ZZ {
-       fn drop(&mut self) {
-               if self.datalen == 0 { return; }
-               unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
+impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::UnsignedChannelUpdate, crate::lightning::ln::msgs::DecodeError>> for CResult_UnsignedChannelUpdateDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::UnsignedChannelUpdate, crate::lightning::ln::msgs::DecodeError>) -> Self {
+               let contents = if o.result_ok {
+                       let result = unsafe { o.contents.result };
+                       unsafe { o.contents.result = std::ptr::null_mut() };
+                       CResult_UnsignedChannelUpdateDecodeErrorZPtr { result }
+               } else {
+                       let err = unsafe { o.contents.err };
+                       unsafe { o.contents.err = std::ptr::null_mut(); }
+                       CResult_UnsignedChannelUpdateDecodeErrorZPtr { err }
+               };
+               Self {
+                       contents,
+                       result_ok: o.result_ok,
+               }
        }
 }
-impl Clone for CVec_CVec_u8ZZ {
+impl Clone for CResult_UnsignedChannelUpdateDecodeErrorZ {
        fn clone(&self) -> Self {
-               let mut res = Vec::new();
-               if self.datalen == 0 { return Self::from(res); }
-               res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
-               Self::from(res)
+               if self.result_ok {
+                       Self { result_ok: true, contents: CResult_UnsignedChannelUpdateDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::UnsignedChannelUpdate>::clone(unsafe { &*self.contents.result })))
+                       } }
+               } else {
+                       Self { result_ok: false, contents: CResult_UnsignedChannelUpdateDecodeErrorZPtr {
+                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
+                       } }
+               }
        }
 }
+#[no_mangle]
+/// Creates a new CResult_UnsignedChannelUpdateDecodeErrorZ which has the same data as `orig`
+/// but with all dynamically-allocated buffers duplicated in new buffers.
+pub extern "C" fn CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig: &CResult_UnsignedChannelUpdateDecodeErrorZ) -> CResult_UnsignedChannelUpdateDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_CVec_CVec_u8ZZNoneZ
-pub union CResult_CVec_CVec_u8ZZNoneZPtr {
+/// The contents of CResult_ChannelUpdateDecodeErrorZ
+pub union CResult_ChannelUpdateDecodeErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::c_types::derived::CVec_CVec_u8ZZ,
-       /// Note that this value is always NULL, as there are no contents in the Err variant
-       pub err: *mut std::ffi::c_void,
+       pub result: *mut crate::lightning::ln::msgs::ChannelUpdate,
+       /// A pointer to the contents in the error state.
+       /// Reading from this pointer when `result_ok` is set is undefined.
+       pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// 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_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`.
-pub struct CResult_CVec_CVec_u8ZZNoneZ {
-       /// The contents of this CResult_CVec_CVec_u8ZZNoneZ, accessible via either
+pub struct CResult_ChannelUpdateDecodeErrorZ {
+       /// The contents of this CResult_ChannelUpdateDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_CVec_CVec_u8ZZNoneZPtr,
-       /// Whether this CResult_CVec_CVec_u8ZZNoneZ represents a success state.
+       pub contents: CResult_ChannelUpdateDecodeErrorZPtr,
+       /// Whether this CResult_ChannelUpdateDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_CVec_CVec_u8ZZNoneZ in the success state.
-pub extern "C" fn CResult_CVec_CVec_u8ZZNoneZ_ok(o: crate::c_types::derived::CVec_CVec_u8ZZ) -> CResult_CVec_CVec_u8ZZNoneZ {
-       CResult_CVec_CVec_u8ZZNoneZ {
-               contents: CResult_CVec_CVec_u8ZZNoneZPtr {
+/// Creates a new CResult_ChannelUpdateDecodeErrorZ in the success state.
+pub extern "C" fn CResult_ChannelUpdateDecodeErrorZ_ok(o: crate::lightning::ln::msgs::ChannelUpdate) -> CResult_ChannelUpdateDecodeErrorZ {
+       CResult_ChannelUpdateDecodeErrorZ {
+               contents: CResult_ChannelUpdateDecodeErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_CVec_CVec_u8ZZNoneZ in the error state.
-pub extern "C" fn CResult_CVec_CVec_u8ZZNoneZ_err() -> CResult_CVec_CVec_u8ZZNoneZ {
-       CResult_CVec_CVec_u8ZZNoneZ {
-               contents: CResult_CVec_CVec_u8ZZNoneZPtr {
-                       err: std::ptr::null_mut(),
+/// Creates a new CResult_ChannelUpdateDecodeErrorZ in the error state.
+pub extern "C" fn CResult_ChannelUpdateDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_ChannelUpdateDecodeErrorZ {
+       CResult_ChannelUpdateDecodeErrorZ {
+               contents: CResult_ChannelUpdateDecodeErrorZPtr {
+                       err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_CVec_CVec_u8ZZNoneZ.
-pub extern "C" fn CResult_CVec_CVec_u8ZZNoneZ_free(_res: CResult_CVec_CVec_u8ZZNoneZ) { }
-impl Drop for CResult_CVec_CVec_u8ZZNoneZ {
+/// Frees any resources used by the CResult_ChannelUpdateDecodeErrorZ.
+pub extern "C" fn CResult_ChannelUpdateDecodeErrorZ_free(_res: CResult_ChannelUpdateDecodeErrorZ) { }
+impl Drop for CResult_ChannelUpdateDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
                                let _ = unsafe { Box::from_raw(self.contents.result) };
                        }
                } else {
+                       if unsafe { !(self.contents.err as *mut ()).is_null() } {
+                               let _ = unsafe { Box::from_raw(self.contents.err) };
+                       }
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::c_types::derived::CVec_CVec_u8ZZ, ()>> for CResult_CVec_CVec_u8ZZNoneZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::c_types::derived::CVec_CVec_u8ZZ, ()>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::ChannelUpdate, crate::lightning::ln::msgs::DecodeError>> for CResult_ChannelUpdateDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::ChannelUpdate, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_CVec_CVec_u8ZZNoneZPtr { result }
+                       CResult_ChannelUpdateDecodeErrorZPtr { result }
                } else {
-                       let _ = unsafe { Box::from_raw(o.contents.err) };
-                       o.contents.err = std::ptr::null_mut();
-                       CResult_CVec_CVec_u8ZZNoneZPtr { err: std::ptr::null_mut() }
+                       let err = unsafe { o.contents.err };
+                       unsafe { o.contents.err = std::ptr::null_mut(); }
+                       CResult_ChannelUpdateDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -9905,68 +10203,68 @@ impl From<crate::c_types::CResultTempl<crate::c_types::derived::CVec_CVec_u8ZZ,
                }
        }
 }
-impl Clone for CResult_CVec_CVec_u8ZZNoneZ {
+impl Clone for CResult_ChannelUpdateDecodeErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_CVec_CVec_u8ZZNoneZPtr {
-                               result: Box::into_raw(Box::new(<crate::c_types::derived::CVec_CVec_u8ZZ>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_ChannelUpdateDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::ChannelUpdate>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_CVec_CVec_u8ZZNoneZPtr {
-                               err: std::ptr::null_mut()
+                       Self { result_ok: false, contents: CResult_ChannelUpdateDecodeErrorZPtr {
+                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_CVec_CVec_u8ZZNoneZ which has the same data as `orig`
+/// Creates a new CResult_ChannelUpdateDecodeErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_CVec_CVec_u8ZZNoneZ_clone(orig: &CResult_CVec_CVec_u8ZZNoneZ) -> CResult_CVec_CVec_u8ZZNoneZ { orig.clone() }
+pub extern "C" fn CResult_ChannelUpdateDecodeErrorZ_clone(orig: &CResult_ChannelUpdateDecodeErrorZ) -> CResult_ChannelUpdateDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_InMemorySignerDecodeErrorZ
-pub union CResult_InMemorySignerDecodeErrorZPtr {
+/// The contents of CResult_ErrorMessageDecodeErrorZ
+pub union CResult_ErrorMessageDecodeErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::lightning::chain::keysinterface::InMemorySigner,
+       pub result: *mut crate::lightning::ln::msgs::ErrorMessage,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
        pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// 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_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`.
-pub struct CResult_InMemorySignerDecodeErrorZ {
-       /// The contents of this CResult_InMemorySignerDecodeErrorZ, accessible via either
+pub struct CResult_ErrorMessageDecodeErrorZ {
+       /// The contents of this CResult_ErrorMessageDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_InMemorySignerDecodeErrorZPtr,
-       /// Whether this CResult_InMemorySignerDecodeErrorZ represents a success state.
+       pub contents: CResult_ErrorMessageDecodeErrorZPtr,
+       /// Whether this CResult_ErrorMessageDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_InMemorySignerDecodeErrorZ in the success state.
-pub extern "C" fn CResult_InMemorySignerDecodeErrorZ_ok(o: crate::lightning::chain::keysinterface::InMemorySigner) -> CResult_InMemorySignerDecodeErrorZ {
-       CResult_InMemorySignerDecodeErrorZ {
-               contents: CResult_InMemorySignerDecodeErrorZPtr {
+/// Creates a new CResult_ErrorMessageDecodeErrorZ in the success state.
+pub extern "C" fn CResult_ErrorMessageDecodeErrorZ_ok(o: crate::lightning::ln::msgs::ErrorMessage) -> CResult_ErrorMessageDecodeErrorZ {
+       CResult_ErrorMessageDecodeErrorZ {
+               contents: CResult_ErrorMessageDecodeErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_InMemorySignerDecodeErrorZ in the error state.
-pub extern "C" fn CResult_InMemorySignerDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_InMemorySignerDecodeErrorZ {
-       CResult_InMemorySignerDecodeErrorZ {
-               contents: CResult_InMemorySignerDecodeErrorZPtr {
+/// Creates a new CResult_ErrorMessageDecodeErrorZ in the error state.
+pub extern "C" fn CResult_ErrorMessageDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_ErrorMessageDecodeErrorZ {
+       CResult_ErrorMessageDecodeErrorZ {
+               contents: CResult_ErrorMessageDecodeErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_InMemorySignerDecodeErrorZ.
-pub extern "C" fn CResult_InMemorySignerDecodeErrorZ_free(_res: CResult_InMemorySignerDecodeErrorZ) { }
-impl Drop for CResult_InMemorySignerDecodeErrorZ {
+/// Frees any resources used by the CResult_ErrorMessageDecodeErrorZ.
+pub extern "C" fn CResult_ErrorMessageDecodeErrorZ_free(_res: CResult_ErrorMessageDecodeErrorZ) { }
+impl Drop for CResult_ErrorMessageDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -9979,16 +10277,16 @@ impl Drop for CResult_InMemorySignerDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::lightning::chain::keysinterface::InMemorySigner, crate::lightning::ln::msgs::DecodeError>> for CResult_InMemorySignerDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::chain::keysinterface::InMemorySigner, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::ErrorMessage, crate::lightning::ln::msgs::DecodeError>> for CResult_ErrorMessageDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::ErrorMessage, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_InMemorySignerDecodeErrorZPtr { result }
+                       CResult_ErrorMessageDecodeErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_InMemorySignerDecodeErrorZPtr { err }
+                       CResult_ErrorMessageDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -9996,132 +10294,181 @@ impl From<crate::c_types::CResultTempl<crate::lightning::chain::keysinterface::I
                }
        }
 }
-impl Clone for CResult_InMemorySignerDecodeErrorZ {
+impl Clone for CResult_ErrorMessageDecodeErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_InMemorySignerDecodeErrorZPtr {
-                               result: Box::into_raw(Box::new(<crate::lightning::chain::keysinterface::InMemorySigner>::clone(unsafe { &*self.contents.result })))
+                       Self { result_ok: true, contents: CResult_ErrorMessageDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::ErrorMessage>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_InMemorySignerDecodeErrorZPtr {
+                       Self { result_ok: false, contents: CResult_ErrorMessageDecodeErrorZPtr {
                                err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_InMemorySignerDecodeErrorZ which has the same data as `orig`
+/// Creates a new CResult_ErrorMessageDecodeErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_InMemorySignerDecodeErrorZ_clone(orig: &CResult_InMemorySignerDecodeErrorZ) -> CResult_InMemorySignerDecodeErrorZ { orig.clone() }
+pub extern "C" fn CResult_ErrorMessageDecodeErrorZ_clone(orig: &CResult_ErrorMessageDecodeErrorZ) -> CResult_ErrorMessageDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// A dynamically-allocated array of crate::c_types::TxOuts of arbitrary size.
-/// This corresponds to std::vector in C++
-pub struct CVec_TxOutZ {
-       /// The elements in the array.
-       /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
-       pub data: *mut crate::c_types::TxOut,
-       /// The number of elements pointed to by `data`.
-       pub datalen: usize
+/// The contents of CResult_UnsignedNodeAnnouncementDecodeErrorZ
+pub union CResult_UnsignedNodeAnnouncementDecodeErrorZPtr {
+       /// A pointer to the contents in the success state.
+       /// Reading from this pointer when `result_ok` is not set is undefined.
+       pub result: *mut crate::lightning::ln::msgs::UnsignedNodeAnnouncement,
+       /// A pointer to the contents in the error state.
+       /// Reading from this pointer when `result_ok` is set is undefined.
+       pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
-impl CVec_TxOutZ {
-       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::c_types::TxOut> {
-               if self.datalen == 0 { return Vec::new(); }
-               let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
-               self.data = std::ptr::null_mut();
-               self.datalen = 0;
-               ret
+#[repr(C)]
+/// 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`.
+pub struct CResult_UnsignedNodeAnnouncementDecodeErrorZ {
+       /// The contents of this CResult_UnsignedNodeAnnouncementDecodeErrorZ, accessible via either
+       /// `err` or `result` depending on the state of `result_ok`.
+       pub contents: CResult_UnsignedNodeAnnouncementDecodeErrorZPtr,
+       /// Whether this CResult_UnsignedNodeAnnouncementDecodeErrorZ represents a success state.
+       pub result_ok: bool,
+}
+#[no_mangle]
+/// Creates a new CResult_UnsignedNodeAnnouncementDecodeErrorZ in the success state.
+pub extern "C" fn CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o: crate::lightning::ln::msgs::UnsignedNodeAnnouncement) -> CResult_UnsignedNodeAnnouncementDecodeErrorZ {
+       CResult_UnsignedNodeAnnouncementDecodeErrorZ {
+               contents: CResult_UnsignedNodeAnnouncementDecodeErrorZPtr {
+                       result: Box::into_raw(Box::new(o)),
+               },
+               result_ok: true,
        }
-       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::c_types::TxOut] {
-               unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
+}
+#[no_mangle]
+/// Creates a new CResult_UnsignedNodeAnnouncementDecodeErrorZ in the error state.
+pub extern "C" fn CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_UnsignedNodeAnnouncementDecodeErrorZ {
+       CResult_UnsignedNodeAnnouncementDecodeErrorZ {
+               contents: CResult_UnsignedNodeAnnouncementDecodeErrorZPtr {
+                       err: Box::into_raw(Box::new(e)),
+               },
+               result_ok: false,
        }
 }
-impl From<Vec<crate::c_types::TxOut>> for CVec_TxOutZ {
-       fn from(v: Vec<crate::c_types::TxOut>) -> Self {
-               let datalen = v.len();
-               let data = Box::into_raw(v.into_boxed_slice());
-               Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
+#[no_mangle]
+/// Frees any resources used by the CResult_UnsignedNodeAnnouncementDecodeErrorZ.
+pub extern "C" fn CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res: CResult_UnsignedNodeAnnouncementDecodeErrorZ) { }
+impl Drop for CResult_UnsignedNodeAnnouncementDecodeErrorZ {
+       fn drop(&mut self) {
+               if self.result_ok {
+                       if unsafe { !(self.contents.result as *mut ()).is_null() } {
+                               let _ = unsafe { Box::from_raw(self.contents.result) };
+                       }
+               } else {
+                       if unsafe { !(self.contents.err as *mut ()).is_null() } {
+                               let _ = unsafe { Box::from_raw(self.contents.err) };
+                       }
+               }
        }
 }
-#[no_mangle]
-/// Frees the buffer pointed to by `data` if `datalen` is non-0.
-pub extern "C" fn CVec_TxOutZ_free(_res: CVec_TxOutZ) { }
-impl Drop for CVec_TxOutZ {
-       fn drop(&mut self) {
-               if self.datalen == 0 { return; }
-               unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
+impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::UnsignedNodeAnnouncement, crate::lightning::ln::msgs::DecodeError>> for CResult_UnsignedNodeAnnouncementDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::UnsignedNodeAnnouncement, crate::lightning::ln::msgs::DecodeError>) -> Self {
+               let contents = if o.result_ok {
+                       let result = unsafe { o.contents.result };
+                       unsafe { o.contents.result = std::ptr::null_mut() };
+                       CResult_UnsignedNodeAnnouncementDecodeErrorZPtr { result }
+               } else {
+                       let err = unsafe { o.contents.err };
+                       unsafe { o.contents.err = std::ptr::null_mut(); }
+                       CResult_UnsignedNodeAnnouncementDecodeErrorZPtr { err }
+               };
+               Self {
+                       contents,
+                       result_ok: o.result_ok,
+               }
        }
 }
-impl Clone for CVec_TxOutZ {
+impl Clone for CResult_UnsignedNodeAnnouncementDecodeErrorZ {
        fn clone(&self) -> Self {
-               let mut res = Vec::new();
-               if self.datalen == 0 { return Self::from(res); }
-               res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
-               Self::from(res)
+               if self.result_ok {
+                       Self { result_ok: true, contents: CResult_UnsignedNodeAnnouncementDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::UnsignedNodeAnnouncement>::clone(unsafe { &*self.contents.result })))
+                       } }
+               } else {
+                       Self { result_ok: false, contents: CResult_UnsignedNodeAnnouncementDecodeErrorZPtr {
+                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
+                       } }
+               }
        }
 }
+#[no_mangle]
+/// Creates a new CResult_UnsignedNodeAnnouncementDecodeErrorZ which has the same data as `orig`
+/// but with all dynamically-allocated buffers duplicated in new buffers.
+pub extern "C" fn CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig: &CResult_UnsignedNodeAnnouncementDecodeErrorZ) -> CResult_UnsignedNodeAnnouncementDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_TransactionNoneZ
-pub union CResult_TransactionNoneZPtr {
+/// The contents of CResult_NodeAnnouncementDecodeErrorZ
+pub union CResult_NodeAnnouncementDecodeErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::c_types::Transaction,
-       /// Note that this value is always NULL, as there are no contents in the Err variant
-       pub err: *mut std::ffi::c_void,
+       pub result: *mut crate::lightning::ln::msgs::NodeAnnouncement,
+       /// A pointer to the contents in the error state.
+       /// Reading from this pointer when `result_ok` is set is undefined.
+       pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// A CResult_TransactionNoneZ represents the result of a fallible operation,
-/// containing a crate::c_types::Transaction on success and a () on failure.
+/// 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`.
-pub struct CResult_TransactionNoneZ {
-       /// The contents of this CResult_TransactionNoneZ, accessible via either
+pub struct CResult_NodeAnnouncementDecodeErrorZ {
+       /// The contents of this CResult_NodeAnnouncementDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_TransactionNoneZPtr,
-       /// Whether this CResult_TransactionNoneZ represents a success state.
+       pub contents: CResult_NodeAnnouncementDecodeErrorZPtr,
+       /// Whether this CResult_NodeAnnouncementDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_TransactionNoneZ in the success state.
-pub extern "C" fn CResult_TransactionNoneZ_ok(o: crate::c_types::Transaction) -> CResult_TransactionNoneZ {
-       CResult_TransactionNoneZ {
-               contents: CResult_TransactionNoneZPtr {
+/// Creates a new CResult_NodeAnnouncementDecodeErrorZ in the success state.
+pub extern "C" fn CResult_NodeAnnouncementDecodeErrorZ_ok(o: crate::lightning::ln::msgs::NodeAnnouncement) -> CResult_NodeAnnouncementDecodeErrorZ {
+       CResult_NodeAnnouncementDecodeErrorZ {
+               contents: CResult_NodeAnnouncementDecodeErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_TransactionNoneZ in the error state.
-pub extern "C" fn CResult_TransactionNoneZ_err() -> CResult_TransactionNoneZ {
-       CResult_TransactionNoneZ {
-               contents: CResult_TransactionNoneZPtr {
-                       err: std::ptr::null_mut(),
+/// Creates a new CResult_NodeAnnouncementDecodeErrorZ in the error state.
+pub extern "C" fn CResult_NodeAnnouncementDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_NodeAnnouncementDecodeErrorZ {
+       CResult_NodeAnnouncementDecodeErrorZ {
+               contents: CResult_NodeAnnouncementDecodeErrorZPtr {
+                       err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_TransactionNoneZ.
-pub extern "C" fn CResult_TransactionNoneZ_free(_res: CResult_TransactionNoneZ) { }
-impl Drop for CResult_TransactionNoneZ {
+/// Frees any resources used by the CResult_NodeAnnouncementDecodeErrorZ.
+pub extern "C" fn CResult_NodeAnnouncementDecodeErrorZ_free(_res: CResult_NodeAnnouncementDecodeErrorZ) { }
+impl Drop for CResult_NodeAnnouncementDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
                                let _ = unsafe { Box::from_raw(self.contents.result) };
                        }
                } else {
+                       if unsafe { !(self.contents.err as *mut ()).is_null() } {
+                               let _ = unsafe { Box::from_raw(self.contents.err) };
+                       }
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::c_types::Transaction, ()>> for CResult_TransactionNoneZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::c_types::Transaction, ()>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::NodeAnnouncement, crate::lightning::ln::msgs::DecodeError>> for CResult_NodeAnnouncementDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::NodeAnnouncement, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_TransactionNoneZPtr { result }
+                       CResult_NodeAnnouncementDecodeErrorZPtr { result }
                } else {
-                       let _ = unsafe { Box::from_raw(o.contents.err) };
-                       o.contents.err = std::ptr::null_mut();
-                       CResult_TransactionNoneZPtr { err: std::ptr::null_mut() }
+                       let err = unsafe { o.contents.err };
+                       unsafe { o.contents.err = std::ptr::null_mut(); }
+                       CResult_NodeAnnouncementDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -10129,52 +10476,73 @@ impl From<crate::c_types::CResultTempl<crate::c_types::Transaction, ()>> for CRe
                }
        }
 }
+impl Clone for CResult_NodeAnnouncementDecodeErrorZ {
+       fn clone(&self) -> Self {
+               if self.result_ok {
+                       Self { result_ok: true, contents: CResult_NodeAnnouncementDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::NodeAnnouncement>::clone(unsafe { &*self.contents.result })))
+                       } }
+               } else {
+                       Self { result_ok: false, contents: CResult_NodeAnnouncementDecodeErrorZPtr {
+                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
+                       } }
+               }
+       }
+}
+#[no_mangle]
+/// Creates a new CResult_NodeAnnouncementDecodeErrorZ which has the same data as `orig`
+/// but with all dynamically-allocated buffers duplicated in new buffers.
+pub extern "C" fn CResult_NodeAnnouncementDecodeErrorZ_clone(orig: &CResult_NodeAnnouncementDecodeErrorZ) -> CResult_NodeAnnouncementDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_NoneErrorZ
-pub union CResult_NoneErrorZPtr {
-       /// Note that this value is always NULL, as there are no contents in the OK variant
-       pub result: *mut std::ffi::c_void,
+/// The contents of CResult_QueryShortChannelIdsDecodeErrorZ
+pub union CResult_QueryShortChannelIdsDecodeErrorZPtr {
+       /// A pointer to the contents in the success state.
+       /// Reading from this pointer when `result_ok` is not set is undefined.
+       pub result: *mut crate::lightning::ln::msgs::QueryShortChannelIds,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::c_types::IOError,
+       pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// A CResult_NoneErrorZ represents the result of a fallible operation,
-/// containing a () on success and a crate::c_types::IOError on failure.
+/// 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`.
-pub struct CResult_NoneErrorZ {
-       /// The contents of this CResult_NoneErrorZ, accessible via either
+pub struct CResult_QueryShortChannelIdsDecodeErrorZ {
+       /// The contents of this CResult_QueryShortChannelIdsDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_NoneErrorZPtr,
-       /// Whether this CResult_NoneErrorZ represents a success state.
+       pub contents: CResult_QueryShortChannelIdsDecodeErrorZPtr,
+       /// Whether this CResult_QueryShortChannelIdsDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_NoneErrorZ in the success state.
-pub extern "C" fn CResult_NoneErrorZ_ok() -> CResult_NoneErrorZ {
-       CResult_NoneErrorZ {
-               contents: CResult_NoneErrorZPtr {
-                       result: std::ptr::null_mut(),
+/// Creates a new CResult_QueryShortChannelIdsDecodeErrorZ in the success state.
+pub extern "C" fn CResult_QueryShortChannelIdsDecodeErrorZ_ok(o: crate::lightning::ln::msgs::QueryShortChannelIds) -> CResult_QueryShortChannelIdsDecodeErrorZ {
+       CResult_QueryShortChannelIdsDecodeErrorZ {
+               contents: CResult_QueryShortChannelIdsDecodeErrorZPtr {
+                       result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_NoneErrorZ in the error state.
-pub extern "C" fn CResult_NoneErrorZ_err(e: crate::c_types::IOError) -> CResult_NoneErrorZ {
-       CResult_NoneErrorZ {
-               contents: CResult_NoneErrorZPtr {
+/// Creates a new CResult_QueryShortChannelIdsDecodeErrorZ in the error state.
+pub extern "C" fn CResult_QueryShortChannelIdsDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_QueryShortChannelIdsDecodeErrorZ {
+       CResult_QueryShortChannelIdsDecodeErrorZ {
+               contents: CResult_QueryShortChannelIdsDecodeErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_NoneErrorZ.
-pub extern "C" fn CResult_NoneErrorZ_free(_res: CResult_NoneErrorZ) { }
-impl Drop for CResult_NoneErrorZ {
+/// Frees any resources used by the CResult_QueryShortChannelIdsDecodeErrorZ.
+pub extern "C" fn CResult_QueryShortChannelIdsDecodeErrorZ_free(_res: CResult_QueryShortChannelIdsDecodeErrorZ) { }
+impl Drop for CResult_QueryShortChannelIdsDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
+                       if unsafe { !(self.contents.result as *mut ()).is_null() } {
+                               let _ = unsafe { Box::from_raw(self.contents.result) };
+                       }
                } else {
                        if unsafe { !(self.contents.err as *mut ()).is_null() } {
                                let _ = unsafe { Box::from_raw(self.contents.err) };
@@ -10182,16 +10550,16 @@ impl Drop for CResult_NoneErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<(), crate::c_types::IOError>> for CResult_NoneErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<(), crate::c_types::IOError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::QueryShortChannelIds, crate::lightning::ln::msgs::DecodeError>> for CResult_QueryShortChannelIdsDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::QueryShortChannelIds, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
-                       let _ = unsafe { Box::from_raw(o.contents.result) };
-                       o.contents.result = std::ptr::null_mut();
-                       CResult_NoneErrorZPtr { result: std::ptr::null_mut() }
+                       let result = unsafe { o.contents.result };
+                       unsafe { o.contents.result = std::ptr::null_mut() };
+                       CResult_QueryShortChannelIdsDecodeErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_NoneErrorZPtr { err }
+                       CResult_QueryShortChannelIdsDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -10199,89 +10567,68 @@ impl From<crate::c_types::CResultTempl<(), crate::c_types::IOError>> for CResult
                }
        }
 }
-#[repr(C)]
-/// A dynamically-allocated array of crate::c_types::derived::C2Tuple_BlockHashChannelMonitorZs of arbitrary size.
-/// This corresponds to std::vector in C++
-pub struct CVec_C2Tuple_BlockHashChannelMonitorZZ {
-       /// The elements in the array.
-       /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
-       pub data: *mut crate::c_types::derived::C2Tuple_BlockHashChannelMonitorZ,
-       /// The number of elements pointed to by `data`.
-       pub datalen: usize
-}
-impl CVec_C2Tuple_BlockHashChannelMonitorZZ {
-       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::c_types::derived::C2Tuple_BlockHashChannelMonitorZ> {
-               if self.datalen == 0 { return Vec::new(); }
-               let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
-               self.data = std::ptr::null_mut();
-               self.datalen = 0;
-               ret
-       }
-       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::c_types::derived::C2Tuple_BlockHashChannelMonitorZ] {
-               unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
-       }
-}
-impl From<Vec<crate::c_types::derived::C2Tuple_BlockHashChannelMonitorZ>> for CVec_C2Tuple_BlockHashChannelMonitorZZ {
-       fn from(v: Vec<crate::c_types::derived::C2Tuple_BlockHashChannelMonitorZ>) -> Self {
-               let datalen = v.len();
-               let data = Box::into_raw(v.into_boxed_slice());
-               Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
+impl Clone for CResult_QueryShortChannelIdsDecodeErrorZ {
+       fn clone(&self) -> Self {
+               if self.result_ok {
+                       Self { result_ok: true, contents: CResult_QueryShortChannelIdsDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::QueryShortChannelIds>::clone(unsafe { &*self.contents.result })))
+                       } }
+               } else {
+                       Self { result_ok: false, contents: CResult_QueryShortChannelIdsDecodeErrorZPtr {
+                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
+                       } }
+               }
        }
 }
 #[no_mangle]
-/// Frees the buffer pointed to by `data` if `datalen` is non-0.
-pub extern "C" fn CVec_C2Tuple_BlockHashChannelMonitorZZ_free(_res: CVec_C2Tuple_BlockHashChannelMonitorZZ) { }
-impl Drop for CVec_C2Tuple_BlockHashChannelMonitorZZ {
-       fn drop(&mut self) {
-               if self.datalen == 0 { return; }
-               unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
-       }
-}
+/// Creates a new CResult_QueryShortChannelIdsDecodeErrorZ which has the same data as `orig`
+/// but with all dynamically-allocated buffers duplicated in new buffers.
+pub extern "C" fn CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig: &CResult_QueryShortChannelIdsDecodeErrorZ) -> CResult_QueryShortChannelIdsDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ
-pub union CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZPtr {
+/// The contents of CResult_ReplyShortChannelIdsEndDecodeErrorZ
+pub union CResult_ReplyShortChannelIdsEndDecodeErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::c_types::derived::CVec_C2Tuple_BlockHashChannelMonitorZZ,
+       pub result: *mut crate::lightning::ln::msgs::ReplyShortChannelIdsEnd,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::c_types::IOError,
+       pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// 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_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`.
-pub struct CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ {
-       /// The contents of this CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ, accessible via either
+pub struct CResult_ReplyShortChannelIdsEndDecodeErrorZ {
+       /// The contents of this CResult_ReplyShortChannelIdsEndDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZPtr,
-       /// Whether this CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ represents a success state.
+       pub contents: CResult_ReplyShortChannelIdsEndDecodeErrorZPtr,
+       /// Whether this CResult_ReplyShortChannelIdsEndDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
-#[no_mangle]
-/// Creates a new CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ in the success state.
-pub extern "C" fn CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_ok(o: crate::c_types::derived::CVec_C2Tuple_BlockHashChannelMonitorZZ) -> CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ {
-       CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ {
-               contents: CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZPtr {
+#[no_mangle]
+/// Creates a new CResult_ReplyShortChannelIdsEndDecodeErrorZ in the success state.
+pub extern "C" fn CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o: crate::lightning::ln::msgs::ReplyShortChannelIdsEnd) -> CResult_ReplyShortChannelIdsEndDecodeErrorZ {
+       CResult_ReplyShortChannelIdsEndDecodeErrorZ {
+               contents: CResult_ReplyShortChannelIdsEndDecodeErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ in the error state.
-pub extern "C" fn CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_err(e: crate::c_types::IOError) -> CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ {
-       CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ {
-               contents: CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZPtr {
+/// Creates a new CResult_ReplyShortChannelIdsEndDecodeErrorZ in the error state.
+pub extern "C" fn CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_ReplyShortChannelIdsEndDecodeErrorZ {
+       CResult_ReplyShortChannelIdsEndDecodeErrorZ {
+               contents: CResult_ReplyShortChannelIdsEndDecodeErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ.
-pub extern "C" fn CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_free(_res: CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ) { }
-impl Drop for CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ {
+/// Frees any resources used by the CResult_ReplyShortChannelIdsEndDecodeErrorZ.
+pub extern "C" fn CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res: CResult_ReplyShortChannelIdsEndDecodeErrorZ) { }
+impl Drop for CResult_ReplyShortChannelIdsEndDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -10294,16 +10641,16 @@ impl Drop for CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::c_types::derived::CVec_C2Tuple_BlockHashChannelMonitorZZ, crate::c_types::IOError>> for CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::c_types::derived::CVec_C2Tuple_BlockHashChannelMonitorZZ, crate::c_types::IOError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::ReplyShortChannelIdsEnd, crate::lightning::ln::msgs::DecodeError>> for CResult_ReplyShortChannelIdsEndDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::ReplyShortChannelIdsEnd, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZPtr { result }
+                       CResult_ReplyShortChannelIdsEndDecodeErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZPtr { err }
+                       CResult_ReplyShortChannelIdsEndDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -10311,52 +10658,73 @@ impl From<crate::c_types::CResultTempl<crate::c_types::derived::CVec_C2Tuple_Blo
                }
        }
 }
+impl Clone for CResult_ReplyShortChannelIdsEndDecodeErrorZ {
+       fn clone(&self) -> Self {
+               if self.result_ok {
+                       Self { result_ok: true, contents: CResult_ReplyShortChannelIdsEndDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::ReplyShortChannelIdsEnd>::clone(unsafe { &*self.contents.result })))
+                       } }
+               } else {
+                       Self { result_ok: false, contents: CResult_ReplyShortChannelIdsEndDecodeErrorZPtr {
+                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
+                       } }
+               }
+       }
+}
+#[no_mangle]
+/// Creates a new CResult_ReplyShortChannelIdsEndDecodeErrorZ which has the same data as `orig`
+/// but with all dynamically-allocated buffers duplicated in new buffers.
+pub extern "C" fn CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig: &CResult_ReplyShortChannelIdsEndDecodeErrorZ) -> CResult_ReplyShortChannelIdsEndDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_NoneAPIErrorZ
-pub union CResult_NoneAPIErrorZPtr {
-       /// Note that this value is always NULL, as there are no contents in the OK variant
-       pub result: *mut std::ffi::c_void,
+/// The contents of CResult_QueryChannelRangeDecodeErrorZ
+pub union CResult_QueryChannelRangeDecodeErrorZPtr {
+       /// A pointer to the contents in the success state.
+       /// Reading from this pointer when `result_ok` is not set is undefined.
+       pub result: *mut crate::lightning::ln::msgs::QueryChannelRange,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::lightning::util::errors::APIError,
+       pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// 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_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`.
-pub struct CResult_NoneAPIErrorZ {
-       /// The contents of this CResult_NoneAPIErrorZ, accessible via either
+pub struct CResult_QueryChannelRangeDecodeErrorZ {
+       /// The contents of this CResult_QueryChannelRangeDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_NoneAPIErrorZPtr,
-       /// Whether this CResult_NoneAPIErrorZ represents a success state.
+       pub contents: CResult_QueryChannelRangeDecodeErrorZPtr,
+       /// Whether this CResult_QueryChannelRangeDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_NoneAPIErrorZ in the success state.
-pub extern "C" fn CResult_NoneAPIErrorZ_ok() -> CResult_NoneAPIErrorZ {
-       CResult_NoneAPIErrorZ {
-               contents: CResult_NoneAPIErrorZPtr {
-                       result: std::ptr::null_mut(),
+/// Creates a new CResult_QueryChannelRangeDecodeErrorZ in the success state.
+pub extern "C" fn CResult_QueryChannelRangeDecodeErrorZ_ok(o: crate::lightning::ln::msgs::QueryChannelRange) -> CResult_QueryChannelRangeDecodeErrorZ {
+       CResult_QueryChannelRangeDecodeErrorZ {
+               contents: CResult_QueryChannelRangeDecodeErrorZPtr {
+                       result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_NoneAPIErrorZ in the error state.
-pub extern "C" fn CResult_NoneAPIErrorZ_err(e: crate::lightning::util::errors::APIError) -> CResult_NoneAPIErrorZ {
-       CResult_NoneAPIErrorZ {
-               contents: CResult_NoneAPIErrorZPtr {
+/// Creates a new CResult_QueryChannelRangeDecodeErrorZ in the error state.
+pub extern "C" fn CResult_QueryChannelRangeDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_QueryChannelRangeDecodeErrorZ {
+       CResult_QueryChannelRangeDecodeErrorZ {
+               contents: CResult_QueryChannelRangeDecodeErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_NoneAPIErrorZ.
-pub extern "C" fn CResult_NoneAPIErrorZ_free(_res: CResult_NoneAPIErrorZ) { }
-impl Drop for CResult_NoneAPIErrorZ {
+/// Frees any resources used by the CResult_QueryChannelRangeDecodeErrorZ.
+pub extern "C" fn CResult_QueryChannelRangeDecodeErrorZ_free(_res: CResult_QueryChannelRangeDecodeErrorZ) { }
+impl Drop for CResult_QueryChannelRangeDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
+                       if unsafe { !(self.contents.result as *mut ()).is_null() } {
+                               let _ = unsafe { Box::from_raw(self.contents.result) };
+                       }
                } else {
                        if unsafe { !(self.contents.err as *mut ()).is_null() } {
                                let _ = unsafe { Box::from_raw(self.contents.err) };
@@ -10364,16 +10732,16 @@ impl Drop for CResult_NoneAPIErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<(), crate::lightning::util::errors::APIError>> for CResult_NoneAPIErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<(), crate::lightning::util::errors::APIError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::QueryChannelRange, crate::lightning::ln::msgs::DecodeError>> for CResult_QueryChannelRangeDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::QueryChannelRange, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
-                       let _ = unsafe { Box::from_raw(o.contents.result) };
-                       o.contents.result = std::ptr::null_mut();
-                       CResult_NoneAPIErrorZPtr { result: std::ptr::null_mut() }
+                       let result = unsafe { o.contents.result };
+                       unsafe { o.contents.result = std::ptr::null_mut() };
+                       CResult_QueryChannelRangeDecodeErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_NoneAPIErrorZPtr { err }
+                       CResult_QueryChannelRangeDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -10381,161 +10749,73 @@ impl From<crate::c_types::CResultTempl<(), crate::lightning::util::errors::APIEr
                }
        }
 }
-impl Clone for CResult_NoneAPIErrorZ {
+impl Clone for CResult_QueryChannelRangeDecodeErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_NoneAPIErrorZPtr {
-                               result: std::ptr::null_mut()
+                       Self { result_ok: true, contents: CResult_QueryChannelRangeDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::QueryChannelRange>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_NoneAPIErrorZPtr {
-                               err: Box::into_raw(Box::new(<crate::lightning::util::errors::APIError>::clone(unsafe { &*self.contents.err })))
+                       Self { result_ok: false, contents: CResult_QueryChannelRangeDecodeErrorZPtr {
+                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_NoneAPIErrorZ which has the same data as `orig`
+/// Creates a new CResult_QueryChannelRangeDecodeErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_NoneAPIErrorZ_clone(orig: &CResult_NoneAPIErrorZ) -> CResult_NoneAPIErrorZ { orig.clone() }
-#[repr(C)]
-/// A dynamically-allocated array of crate::c_types::derived::CResult_NoneAPIErrorZs of arbitrary size.
-/// This corresponds to std::vector in C++
-pub struct CVec_CResult_NoneAPIErrorZZ {
-       /// The elements in the array.
-       /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
-       pub data: *mut crate::c_types::derived::CResult_NoneAPIErrorZ,
-       /// The number of elements pointed to by `data`.
-       pub datalen: usize
-}
-impl CVec_CResult_NoneAPIErrorZZ {
-       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::c_types::derived::CResult_NoneAPIErrorZ> {
-               if self.datalen == 0 { return Vec::new(); }
-               let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
-               self.data = std::ptr::null_mut();
-               self.datalen = 0;
-               ret
-       }
-       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::c_types::derived::CResult_NoneAPIErrorZ] {
-               unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
-       }
-}
-impl From<Vec<crate::c_types::derived::CResult_NoneAPIErrorZ>> for CVec_CResult_NoneAPIErrorZZ {
-       fn from(v: Vec<crate::c_types::derived::CResult_NoneAPIErrorZ>) -> Self {
-               let datalen = v.len();
-               let data = Box::into_raw(v.into_boxed_slice());
-               Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
-       }
-}
-#[no_mangle]
-/// Frees the buffer pointed to by `data` if `datalen` is non-0.
-pub extern "C" fn CVec_CResult_NoneAPIErrorZZ_free(_res: CVec_CResult_NoneAPIErrorZZ) { }
-impl Drop for CVec_CResult_NoneAPIErrorZZ {
-       fn drop(&mut self) {
-               if self.datalen == 0 { return; }
-               unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
-       }
-}
-impl Clone for CVec_CResult_NoneAPIErrorZZ {
-       fn clone(&self) -> Self {
-               let mut res = Vec::new();
-               if self.datalen == 0 { return Self::from(res); }
-               res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
-               Self::from(res)
-       }
-}
-#[repr(C)]
-/// A dynamically-allocated array of crate::lightning::util::errors::APIErrors of arbitrary size.
-/// This corresponds to std::vector in C++
-pub struct CVec_APIErrorZ {
-       /// The elements in the array.
-       /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
-       pub data: *mut crate::lightning::util::errors::APIError,
-       /// The number of elements pointed to by `data`.
-       pub datalen: usize
-}
-impl CVec_APIErrorZ {
-       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::lightning::util::errors::APIError> {
-               if self.datalen == 0 { return Vec::new(); }
-               let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
-               self.data = std::ptr::null_mut();
-               self.datalen = 0;
-               ret
-       }
-       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::lightning::util::errors::APIError] {
-               unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
-       }
-}
-impl From<Vec<crate::lightning::util::errors::APIError>> for CVec_APIErrorZ {
-       fn from(v: Vec<crate::lightning::util::errors::APIError>) -> Self {
-               let datalen = v.len();
-               let data = Box::into_raw(v.into_boxed_slice());
-               Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
-       }
-}
-#[no_mangle]
-/// Frees the buffer pointed to by `data` if `datalen` is non-0.
-pub extern "C" fn CVec_APIErrorZ_free(_res: CVec_APIErrorZ) { }
-impl Drop for CVec_APIErrorZ {
-       fn drop(&mut self) {
-               if self.datalen == 0 { return; }
-               unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
-       }
-}
-impl Clone for CVec_APIErrorZ {
-       fn clone(&self) -> Self {
-               let mut res = Vec::new();
-               if self.datalen == 0 { return Self::from(res); }
-               res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
-               Self::from(res)
-       }
-}
+pub extern "C" fn CResult_QueryChannelRangeDecodeErrorZ_clone(orig: &CResult_QueryChannelRangeDecodeErrorZ) -> CResult_QueryChannelRangeDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_NonePaymentSendFailureZ
-pub union CResult_NonePaymentSendFailureZPtr {
-       /// Note that this value is always NULL, as there are no contents in the OK variant
-       pub result: *mut std::ffi::c_void,
+/// The contents of CResult_ReplyChannelRangeDecodeErrorZ
+pub union CResult_ReplyChannelRangeDecodeErrorZPtr {
+       /// A pointer to the contents in the success state.
+       /// Reading from this pointer when `result_ok` is not set is undefined.
+       pub result: *mut crate::lightning::ln::msgs::ReplyChannelRange,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::lightning::ln::channelmanager::PaymentSendFailure,
+       pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// 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_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`.
-pub struct CResult_NonePaymentSendFailureZ {
-       /// The contents of this CResult_NonePaymentSendFailureZ, accessible via either
+pub struct CResult_ReplyChannelRangeDecodeErrorZ {
+       /// The contents of this CResult_ReplyChannelRangeDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_NonePaymentSendFailureZPtr,
-       /// Whether this CResult_NonePaymentSendFailureZ represents a success state.
+       pub contents: CResult_ReplyChannelRangeDecodeErrorZPtr,
+       /// Whether this CResult_ReplyChannelRangeDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_NonePaymentSendFailureZ in the success state.
-pub extern "C" fn CResult_NonePaymentSendFailureZ_ok() -> CResult_NonePaymentSendFailureZ {
-       CResult_NonePaymentSendFailureZ {
-               contents: CResult_NonePaymentSendFailureZPtr {
-                       result: std::ptr::null_mut(),
+/// Creates a new CResult_ReplyChannelRangeDecodeErrorZ in the success state.
+pub extern "C" fn CResult_ReplyChannelRangeDecodeErrorZ_ok(o: crate::lightning::ln::msgs::ReplyChannelRange) -> CResult_ReplyChannelRangeDecodeErrorZ {
+       CResult_ReplyChannelRangeDecodeErrorZ {
+               contents: CResult_ReplyChannelRangeDecodeErrorZPtr {
+                       result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_NonePaymentSendFailureZ in the error state.
-pub extern "C" fn CResult_NonePaymentSendFailureZ_err(e: crate::lightning::ln::channelmanager::PaymentSendFailure) -> CResult_NonePaymentSendFailureZ {
-       CResult_NonePaymentSendFailureZ {
-               contents: CResult_NonePaymentSendFailureZPtr {
+/// Creates a new CResult_ReplyChannelRangeDecodeErrorZ in the error state.
+pub extern "C" fn CResult_ReplyChannelRangeDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_ReplyChannelRangeDecodeErrorZ {
+       CResult_ReplyChannelRangeDecodeErrorZ {
+               contents: CResult_ReplyChannelRangeDecodeErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_NonePaymentSendFailureZ.
-pub extern "C" fn CResult_NonePaymentSendFailureZ_free(_res: CResult_NonePaymentSendFailureZ) { }
-impl Drop for CResult_NonePaymentSendFailureZ {
+/// Frees any resources used by the CResult_ReplyChannelRangeDecodeErrorZ.
+pub extern "C" fn CResult_ReplyChannelRangeDecodeErrorZ_free(_res: CResult_ReplyChannelRangeDecodeErrorZ) { }
+impl Drop for CResult_ReplyChannelRangeDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
+                       if unsafe { !(self.contents.result as *mut ()).is_null() } {
+                               let _ = unsafe { Box::from_raw(self.contents.result) };
+                       }
                } else {
                        if unsafe { !(self.contents.err as *mut ()).is_null() } {
                                let _ = unsafe { Box::from_raw(self.contents.err) };
@@ -10543,16 +10823,16 @@ impl Drop for CResult_NonePaymentSendFailureZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<(), crate::lightning::ln::channelmanager::PaymentSendFailure>> for CResult_NonePaymentSendFailureZ {
-       fn from(mut o: crate::c_types::CResultTempl<(), crate::lightning::ln::channelmanager::PaymentSendFailure>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::ReplyChannelRange, crate::lightning::ln::msgs::DecodeError>> for CResult_ReplyChannelRangeDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::ReplyChannelRange, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
-                       let _ = unsafe { Box::from_raw(o.contents.result) };
-                       o.contents.result = std::ptr::null_mut();
-                       CResult_NonePaymentSendFailureZPtr { result: std::ptr::null_mut() }
+                       let result = unsafe { o.contents.result };
+                       unsafe { o.contents.result = std::ptr::null_mut() };
+                       CResult_ReplyChannelRangeDecodeErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_NonePaymentSendFailureZPtr { err }
+                       CResult_ReplyChannelRangeDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -10560,98 +10840,68 @@ impl From<crate::c_types::CResultTempl<(), crate::lightning::ln::channelmanager:
                }
        }
 }
-impl Clone for CResult_NonePaymentSendFailureZ {
+impl Clone for CResult_ReplyChannelRangeDecodeErrorZ {
        fn clone(&self) -> Self {
                if self.result_ok {
-                       Self { result_ok: true, contents: CResult_NonePaymentSendFailureZPtr {
-                               result: std::ptr::null_mut()
+                       Self { result_ok: true, contents: CResult_ReplyChannelRangeDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::ReplyChannelRange>::clone(unsafe { &*self.contents.result })))
                        } }
                } else {
-                       Self { result_ok: false, contents: CResult_NonePaymentSendFailureZPtr {
-                               err: Box::into_raw(Box::new(<crate::lightning::ln::channelmanager::PaymentSendFailure>::clone(unsafe { &*self.contents.err })))
+                       Self { result_ok: false, contents: CResult_ReplyChannelRangeDecodeErrorZPtr {
+                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
                        } }
                }
        }
 }
 #[no_mangle]
-/// Creates a new CResult_NonePaymentSendFailureZ which has the same data as `orig`
+/// Creates a new CResult_ReplyChannelRangeDecodeErrorZ which has the same data as `orig`
 /// but with all dynamically-allocated buffers duplicated in new buffers.
-pub extern "C" fn CResult_NonePaymentSendFailureZ_clone(orig: &CResult_NonePaymentSendFailureZ) -> CResult_NonePaymentSendFailureZ { orig.clone() }
-#[repr(C)]
-/// A tuple of 2 elements. See the individual fields for the types contained.
-pub struct C2Tuple_PaymentHashPaymentSecretZ {
-       /// The element at position 0
-       pub a: crate::c_types::ThirtyTwoBytes,
-       /// The element at position 1
-       pub b: crate::c_types::ThirtyTwoBytes,
-}
-impl From<(crate::c_types::ThirtyTwoBytes, crate::c_types::ThirtyTwoBytes)> for C2Tuple_PaymentHashPaymentSecretZ {
-       fn from (tup: (crate::c_types::ThirtyTwoBytes, crate::c_types::ThirtyTwoBytes)) -> Self {
-               Self {
-                       a: tup.0,
-                       b: tup.1,
-               }
-       }
-}
-impl C2Tuple_PaymentHashPaymentSecretZ {
-       #[allow(unused)] pub(crate) fn to_rust(mut self) -> (crate::c_types::ThirtyTwoBytes, crate::c_types::ThirtyTwoBytes) {
-               (self.a, self.b)
-       }
-}
-/// Creates a new C2Tuple_PaymentHashPaymentSecretZ from the contained elements.
-#[no_mangle]
-pub extern "C" fn C2Tuple_PaymentHashPaymentSecretZ_new(a: crate::c_types::ThirtyTwoBytes, b: crate::c_types::ThirtyTwoBytes) -> C2Tuple_PaymentHashPaymentSecretZ {
-       C2Tuple_PaymentHashPaymentSecretZ { a, b, }
-}
-
-#[no_mangle]
-/// Frees any resources used by the C2Tuple_PaymentHashPaymentSecretZ.
-pub extern "C" fn C2Tuple_PaymentHashPaymentSecretZ_free(_res: C2Tuple_PaymentHashPaymentSecretZ) { }
+pub extern "C" fn CResult_ReplyChannelRangeDecodeErrorZ_clone(orig: &CResult_ReplyChannelRangeDecodeErrorZ) -> CResult_ReplyChannelRangeDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_PaymentSecretAPIErrorZ
-pub union CResult_PaymentSecretAPIErrorZPtr {
+/// The contents of CResult_GossipTimestampFilterDecodeErrorZ
+pub union CResult_GossipTimestampFilterDecodeErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::c_types::ThirtyTwoBytes,
+       pub result: *mut crate::lightning::ln::msgs::GossipTimestampFilter,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::lightning::util::errors::APIError,
+       pub err: *mut crate::lightning::ln::msgs::DecodeError,
 }
 #[repr(C)]
-/// A CResult_PaymentSecretAPIErrorZ represents the result of a fallible operation,
-/// containing a crate::c_types::ThirtyTwoBytes on success and a crate::lightning::util::errors::APIError 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`.
-pub struct CResult_PaymentSecretAPIErrorZ {
-       /// The contents of this CResult_PaymentSecretAPIErrorZ, accessible via either
+pub struct CResult_GossipTimestampFilterDecodeErrorZ {
+       /// The contents of this CResult_GossipTimestampFilterDecodeErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_PaymentSecretAPIErrorZPtr,
-       /// Whether this CResult_PaymentSecretAPIErrorZ represents a success state.
+       pub contents: CResult_GossipTimestampFilterDecodeErrorZPtr,
+       /// Whether this CResult_GossipTimestampFilterDecodeErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_PaymentSecretAPIErrorZ in the success state.
-pub extern "C" fn CResult_PaymentSecretAPIErrorZ_ok(o: crate::c_types::ThirtyTwoBytes) -> CResult_PaymentSecretAPIErrorZ {
-       CResult_PaymentSecretAPIErrorZ {
-               contents: CResult_PaymentSecretAPIErrorZPtr {
+/// Creates a new CResult_GossipTimestampFilterDecodeErrorZ in the success state.
+pub extern "C" fn CResult_GossipTimestampFilterDecodeErrorZ_ok(o: crate::lightning::ln::msgs::GossipTimestampFilter) -> CResult_GossipTimestampFilterDecodeErrorZ {
+       CResult_GossipTimestampFilterDecodeErrorZ {
+               contents: CResult_GossipTimestampFilterDecodeErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_PaymentSecretAPIErrorZ in the error state.
-pub extern "C" fn CResult_PaymentSecretAPIErrorZ_err(e: crate::lightning::util::errors::APIError) -> CResult_PaymentSecretAPIErrorZ {
-       CResult_PaymentSecretAPIErrorZ {
-               contents: CResult_PaymentSecretAPIErrorZPtr {
+/// Creates a new CResult_GossipTimestampFilterDecodeErrorZ in the error state.
+pub extern "C" fn CResult_GossipTimestampFilterDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_GossipTimestampFilterDecodeErrorZ {
+       CResult_GossipTimestampFilterDecodeErrorZ {
+               contents: CResult_GossipTimestampFilterDecodeErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_PaymentSecretAPIErrorZ.
-pub extern "C" fn CResult_PaymentSecretAPIErrorZ_free(_res: CResult_PaymentSecretAPIErrorZ) { }
-impl Drop for CResult_PaymentSecretAPIErrorZ {
+/// Frees any resources used by the CResult_GossipTimestampFilterDecodeErrorZ.
+pub extern "C" fn CResult_GossipTimestampFilterDecodeErrorZ_free(_res: CResult_GossipTimestampFilterDecodeErrorZ) { }
+impl Drop for CResult_GossipTimestampFilterDecodeErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -10664,16 +10914,16 @@ impl Drop for CResult_PaymentSecretAPIErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::c_types::ThirtyTwoBytes, crate::lightning::util::errors::APIError>> for CResult_PaymentSecretAPIErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::c_types::ThirtyTwoBytes, crate::lightning::util::errors::APIError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning::ln::msgs::GossipTimestampFilter, crate::lightning::ln::msgs::DecodeError>> for CResult_GossipTimestampFilterDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::ln::msgs::GossipTimestampFilter, crate::lightning::ln::msgs::DecodeError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_PaymentSecretAPIErrorZPtr { result }
+                       CResult_GossipTimestampFilterDecodeErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_PaymentSecretAPIErrorZPtr { err }
+                       CResult_GossipTimestampFilterDecodeErrorZPtr { err }
                };
                Self {
                        contents,
@@ -10681,119 +10931,68 @@ impl From<crate::c_types::CResultTempl<crate::c_types::ThirtyTwoBytes, crate::li
                }
        }
 }
-#[repr(C)]
-/// A dynamically-allocated array of crate::lightning::chain::channelmonitor::ChannelMonitors of arbitrary size.
-/// This corresponds to std::vector in C++
-pub struct CVec_ChannelMonitorZ {
-       /// The elements in the array.
-       /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
-       pub data: *mut crate::lightning::chain::channelmonitor::ChannelMonitor,
-       /// The number of elements pointed to by `data`.
-       pub datalen: usize
-}
-impl CVec_ChannelMonitorZ {
-       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::lightning::chain::channelmonitor::ChannelMonitor> {
-               if self.datalen == 0 { return Vec::new(); }
-               let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
-               self.data = std::ptr::null_mut();
-               self.datalen = 0;
-               ret
-       }
-       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::lightning::chain::channelmonitor::ChannelMonitor] {
-               unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
-       }
-}
-impl From<Vec<crate::lightning::chain::channelmonitor::ChannelMonitor>> for CVec_ChannelMonitorZ {
-       fn from(v: Vec<crate::lightning::chain::channelmonitor::ChannelMonitor>) -> Self {
-               let datalen = v.len();
-               let data = Box::into_raw(v.into_boxed_slice());
-               Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
-       }
-}
-#[no_mangle]
-/// Frees the buffer pointed to by `data` if `datalen` is non-0.
-pub extern "C" fn CVec_ChannelMonitorZ_free(_res: CVec_ChannelMonitorZ) { }
-impl Drop for CVec_ChannelMonitorZ {
-       fn drop(&mut self) {
-               if self.datalen == 0 { return; }
-               unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
-       }
-}
-#[repr(C)]
-/// A tuple of 2 elements. See the individual fields for the types contained.
-pub struct C2Tuple_BlockHashChannelManagerZ {
-       /// The element at position 0
-       pub a: crate::c_types::ThirtyTwoBytes,
-       /// The element at position 1
-       pub b: crate::lightning::ln::channelmanager::ChannelManager,
-}
-impl From<(crate::c_types::ThirtyTwoBytes, crate::lightning::ln::channelmanager::ChannelManager)> for C2Tuple_BlockHashChannelManagerZ {
-       fn from (tup: (crate::c_types::ThirtyTwoBytes, crate::lightning::ln::channelmanager::ChannelManager)) -> Self {
-               Self {
-                       a: tup.0,
-                       b: tup.1,
+impl Clone for CResult_GossipTimestampFilterDecodeErrorZ {
+       fn clone(&self) -> Self {
+               if self.result_ok {
+                       Self { result_ok: true, contents: CResult_GossipTimestampFilterDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::ln::msgs::GossipTimestampFilter>::clone(unsafe { &*self.contents.result })))
+                       } }
+               } else {
+                       Self { result_ok: false, contents: CResult_GossipTimestampFilterDecodeErrorZPtr {
+                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
+                       } }
                }
        }
 }
-impl C2Tuple_BlockHashChannelManagerZ {
-       #[allow(unused)] pub(crate) fn to_rust(mut self) -> (crate::c_types::ThirtyTwoBytes, crate::lightning::ln::channelmanager::ChannelManager) {
-               (self.a, self.b)
-       }
-}
-/// Creates a new C2Tuple_BlockHashChannelManagerZ from the contained elements.
-#[no_mangle]
-pub extern "C" fn C2Tuple_BlockHashChannelManagerZ_new(a: crate::c_types::ThirtyTwoBytes, b: crate::lightning::ln::channelmanager::ChannelManager) -> C2Tuple_BlockHashChannelManagerZ {
-       C2Tuple_BlockHashChannelManagerZ { a, b, }
-}
-
 #[no_mangle]
-/// Frees any resources used by the C2Tuple_BlockHashChannelManagerZ.
-pub extern "C" fn C2Tuple_BlockHashChannelManagerZ_free(_res: C2Tuple_BlockHashChannelManagerZ) { }
+/// Creates a new CResult_GossipTimestampFilterDecodeErrorZ which has the same data as `orig`
+/// but with all dynamically-allocated buffers duplicated in new buffers.
+pub extern "C" fn CResult_GossipTimestampFilterDecodeErrorZ_clone(orig: &CResult_GossipTimestampFilterDecodeErrorZ) -> CResult_GossipTimestampFilterDecodeErrorZ { orig.clone() }
 #[repr(C)]
-/// The contents of CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ
-pub union CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZPtr {
+/// The contents of CResult_InvoiceSignOrCreationErrorZ
+pub union CResult_InvoiceSignOrCreationErrorZPtr {
        /// A pointer to the contents in the success state.
        /// Reading from this pointer when `result_ok` is not set is undefined.
-       pub result: *mut crate::c_types::derived::C2Tuple_BlockHashChannelManagerZ,
+       pub result: *mut crate::lightning_invoice::Invoice,
        /// A pointer to the contents in the error state.
        /// Reading from this pointer when `result_ok` is set is undefined.
-       pub err: *mut crate::lightning::ln::msgs::DecodeError,
+       pub err: *mut crate::lightning_invoice::SignOrCreationError,
 }
 #[repr(C)]
-/// 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_InvoiceSignOrCreationErrorZ represents the result of a fallible operation,
+/// containing a crate::lightning_invoice::Invoice on success and a crate::lightning_invoice::SignOrCreationError on failure.
 /// `result_ok` indicates the overall state, and the contents are provided via `contents`.
-pub struct CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ {
-       /// The contents of this CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ, accessible via either
+pub struct CResult_InvoiceSignOrCreationErrorZ {
+       /// The contents of this CResult_InvoiceSignOrCreationErrorZ, accessible via either
        /// `err` or `result` depending on the state of `result_ok`.
-       pub contents: CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZPtr,
-       /// Whether this CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ represents a success state.
+       pub contents: CResult_InvoiceSignOrCreationErrorZPtr,
+       /// Whether this CResult_InvoiceSignOrCreationErrorZ represents a success state.
        pub result_ok: bool,
 }
 #[no_mangle]
-/// Creates a new CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ in the success state.
-pub extern "C" fn CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o: crate::c_types::derived::C2Tuple_BlockHashChannelManagerZ) -> CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ {
-       CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ {
-               contents: CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZPtr {
+/// Creates a new CResult_InvoiceSignOrCreationErrorZ in the success state.
+pub extern "C" fn CResult_InvoiceSignOrCreationErrorZ_ok(o: crate::lightning_invoice::Invoice) -> CResult_InvoiceSignOrCreationErrorZ {
+       CResult_InvoiceSignOrCreationErrorZ {
+               contents: CResult_InvoiceSignOrCreationErrorZPtr {
                        result: Box::into_raw(Box::new(o)),
                },
                result_ok: true,
        }
 }
 #[no_mangle]
-/// Creates a new CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ in the error state.
-pub extern "C" fn CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ {
-       CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ {
-               contents: CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZPtr {
+/// Creates a new CResult_InvoiceSignOrCreationErrorZ in the error state.
+pub extern "C" fn CResult_InvoiceSignOrCreationErrorZ_err(e: crate::lightning_invoice::SignOrCreationError) -> CResult_InvoiceSignOrCreationErrorZ {
+       CResult_InvoiceSignOrCreationErrorZ {
+               contents: CResult_InvoiceSignOrCreationErrorZPtr {
                        err: Box::into_raw(Box::new(e)),
                },
                result_ok: false,
        }
 }
 #[no_mangle]
-/// Frees any resources used by the CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ.
-pub extern "C" fn CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res: CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ) { }
-impl Drop for CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ {
+/// Frees any resources used by the CResult_InvoiceSignOrCreationErrorZ.
+pub extern "C" fn CResult_InvoiceSignOrCreationErrorZ_free(_res: CResult_InvoiceSignOrCreationErrorZ) { }
+impl Drop for CResult_InvoiceSignOrCreationErrorZ {
        fn drop(&mut self) {
                if self.result_ok {
                        if unsafe { !(self.contents.result as *mut ()).is_null() } {
@@ -10806,16 +11005,16 @@ impl Drop for CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ {
                }
        }
 }
-impl From<crate::c_types::CResultTempl<crate::c_types::derived::C2Tuple_BlockHashChannelManagerZ, crate::lightning::ln::msgs::DecodeError>> for CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ {
-       fn from(mut o: crate::c_types::CResultTempl<crate::c_types::derived::C2Tuple_BlockHashChannelManagerZ, crate::lightning::ln::msgs::DecodeError>) -> Self {
+impl From<crate::c_types::CResultTempl<crate::lightning_invoice::Invoice, crate::lightning_invoice::SignOrCreationError>> for CResult_InvoiceSignOrCreationErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning_invoice::Invoice, crate::lightning_invoice::SignOrCreationError>) -> Self {
                let contents = if o.result_ok {
                        let result = unsafe { o.contents.result };
                        unsafe { o.contents.result = std::ptr::null_mut() };
-                       CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZPtr { result }
+                       CResult_InvoiceSignOrCreationErrorZPtr { result }
                } else {
                        let err = unsafe { o.contents.err };
                        unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZPtr { err }
+                       CResult_InvoiceSignOrCreationErrorZPtr { err }
                };
                Self {
                        contents,
@@ -10823,3 +11022,20 @@ impl From<crate::c_types::CResultTempl<crate::c_types::derived::C2Tuple_BlockHas
                }
        }
 }
+impl Clone for CResult_InvoiceSignOrCreationErrorZ {
+       fn clone(&self) -> Self {
+               if self.result_ok {
+                       Self { result_ok: true, contents: CResult_InvoiceSignOrCreationErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning_invoice::Invoice>::clone(unsafe { &*self.contents.result })))
+                       } }
+               } else {
+                       Self { result_ok: false, contents: CResult_InvoiceSignOrCreationErrorZPtr {
+                               err: Box::into_raw(Box::new(<crate::lightning_invoice::SignOrCreationError>::clone(unsafe { &*self.contents.err })))
+                       } }
+               }
+       }
+}
+#[no_mangle]
+/// Creates a new CResult_InvoiceSignOrCreationErrorZ which has the same data as `orig`
+/// but with all dynamically-allocated buffers duplicated in new buffers.
+pub extern "C" fn CResult_InvoiceSignOrCreationErrorZ_clone(orig: &CResult_InvoiceSignOrCreationErrorZ) -> CResult_InvoiceSignOrCreationErrorZ { orig.clone() }
index e4b62ba01da763a82f52bd3187b4ba75e7d7b048..907c3666161eb3d63195016e8714c9ed99d7cf22 100644 (file)
@@ -21,4 +21,5 @@ pub mod c_types;
 pub mod bitcoin;
 pub mod lightning;
 pub mod lightning_persister;
+pub mod lightning_background_processor;
 pub mod lightning_invoice;
index 17cff8bb34ad124795820988422695697a41c876..e6494e26bac7c55fdd7ed911f8204ee3ab788351 100644 (file)
@@ -29,6 +29,8 @@ pub struct BroadcasterInterface {
        /// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
        pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
 }
+unsafe impl Send for BroadcasterInterface {}
+unsafe impl Sync for BroadcasterInterface {}
 
 use lightning::chain::chaininterface::BroadcasterInterface as rustBroadcasterInterface;
 impl rustBroadcasterInterface for BroadcasterInterface {
@@ -132,6 +134,8 @@ pub struct FeeEstimator {
        /// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
        pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
 }
+unsafe impl Send for FeeEstimator {}
+unsafe impl Sync for FeeEstimator {}
 
 use lightning::chain::chaininterface::FeeEstimator as rustFeeEstimator;
 impl rustFeeEstimator for FeeEstimator {
index 41b9daa983bac821e3bbd79fc8e64998b49e412c..1331506e033bbff55b2809c499c100488221aa48 100644 (file)
@@ -774,6 +774,8 @@ pub struct Persist {
        /// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
        pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
 }
+unsafe impl Send for Persist {}
+unsafe impl Sync for Persist {}
 
 use lightning::chain::channelmonitor::Persist as rustPersist;
 impl rustPersist<crate::lightning::chain::keysinterface::Sign> for Persist {
index 64e300efb6aaf192f230aea64a6d43d081d831ba..b043fccf02ab6967a1c9775039da1df465bbd003 100644 (file)
@@ -645,6 +645,8 @@ pub struct BaseSign {
        /// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
        pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
 }
+unsafe impl Send for BaseSign {}
+unsafe impl Sync for BaseSign {}
 
 use lightning::chain::keysinterface::BaseSign as rustBaseSign;
 impl rustBaseSign for BaseSign {
@@ -749,6 +751,8 @@ pub struct Sign {
        /// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
        pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
 }
+unsafe impl Send for Sign {}
+unsafe impl Sync for Sign {}
 impl lightning::chain::keysinterface::BaseSign for Sign {
        fn get_per_commitment_point(&self, mut idx: u64, mut _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> bitcoin::secp256k1::key::PublicKey {
                let mut ret = (self.BaseSign.get_per_commitment_point)(self.this_arg, idx);
@@ -908,6 +912,8 @@ pub struct KeysInterface {
        /// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
        pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
 }
+unsafe impl Send for KeysInterface {}
+unsafe impl Sync for KeysInterface {}
 
 use lightning::chain::keysinterface::KeysInterface as rustKeysInterface;
 impl rustKeysInterface for KeysInterface {
index 1f0e01921176dbb00f10b3a9bcbd7de2fec0680a..63d70e3ebefa49dff37106fad5be87d715a85810 100644 (file)
@@ -98,6 +98,8 @@ pub struct Access {
        /// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
        pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
 }
+unsafe impl Send for Access {}
+unsafe impl Sync for Access {}
 
 use lightning::chain::Access as rustAccess;
 impl rustAccess for Access {
@@ -146,6 +148,8 @@ pub struct Listen {
        /// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
        pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
 }
+unsafe impl Send for Listen {}
+unsafe impl Sync for Listen {}
 
 use lightning::chain::Listen as rustListen;
 impl rustListen for Listen {
@@ -261,6 +265,8 @@ pub struct Confirm {
        /// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
        pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
 }
+unsafe impl Send for Confirm {}
+unsafe impl Sync for Confirm {}
 
 use lightning::chain::Confirm as rustConfirm;
 impl rustConfirm for Confirm {
@@ -355,6 +361,8 @@ pub struct Watch {
        /// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
        pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
 }
+unsafe impl Send for Watch {}
+unsafe impl Sync for Watch {}
 
 use lightning::chain::Watch as rustWatch;
 impl rustWatch<crate::lightning::chain::keysinterface::Sign> for Watch {
@@ -436,6 +444,8 @@ pub struct Filter {
        /// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
        pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
 }
+unsafe impl Send for Filter {}
+unsafe impl Sync for Filter {}
 
 use lightning::chain::Filter as rustFilter;
 impl rustFilter for Filter {
index 0bdb9faee905d77dfc995892fffb41351c268b4d..4bf1f4d57e7579097bd3bd0d7184d38cda382ee2 100644 (file)
@@ -4526,6 +4526,8 @@ pub struct ChannelMessageHandler {
        /// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
        pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
 }
+unsafe impl Send for ChannelMessageHandler {}
+unsafe impl Sync for ChannelMessageHandler {}
 impl lightning::util::events::MessageSendEventsProvider for ChannelMessageHandler {
        fn get_and_clear_pending_msg_events(&self) -> Vec<lightning::util::events::MessageSendEvent> {
                let mut ret = (self.MessageSendEventsProvider.get_and_clear_pending_msg_events)(self.this_arg);
@@ -4682,6 +4684,8 @@ pub struct RoutingMessageHandler {
        /// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
        pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
 }
+unsafe impl Send for RoutingMessageHandler {}
+unsafe impl Sync for RoutingMessageHandler {}
 impl lightning::util::events::MessageSendEventsProvider for RoutingMessageHandler {
        fn get_and_clear_pending_msg_events(&self) -> Vec<lightning::util::events::MessageSendEvent> {
                let mut ret = (self.MessageSendEventsProvider.get_and_clear_pending_msg_events)(self.this_arg);
index b832b1f15ca0b2cd43b63b7c0f032cb1e0be7e2a..413c144246fc291981b9297cb286a819357e713b 100644 (file)
@@ -517,6 +517,8 @@ pub struct SocketDescriptor {
        /// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
        pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
 }
+unsafe impl Send for SocketDescriptor {}
+unsafe impl Sync for SocketDescriptor {}
 impl std::cmp::Eq for SocketDescriptor {}
 impl std::cmp::PartialEq for SocketDescriptor {
        fn eq(&self, o: &Self) -> bool { (self.eq)(self.this_arg, o) }
index 2aea6ac993cc766a7e9252f1504b85a33a40ae96..944d86159ab2a60a847be85c67dda2004a4394a7 100644 (file)
@@ -1055,6 +1055,8 @@ pub struct MessageSendEventsProvider {
        /// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
        pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
 }
+unsafe impl Send for MessageSendEventsProvider {}
+unsafe impl Sync for MessageSendEventsProvider {}
 
 use lightning::util::events::MessageSendEventsProvider as rustMessageSendEventsProvider;
 impl rustMessageSendEventsProvider for MessageSendEventsProvider {
@@ -1122,6 +1124,8 @@ pub struct EventsProvider {
        /// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
        pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
 }
+unsafe impl Send for EventsProvider {}
+unsafe impl Sync for EventsProvider {}
 
 use lightning::util::events::EventsProvider as rustEventsProvider;
 /// Calls the free function if one is set
@@ -1148,6 +1152,8 @@ pub struct EventHandler {
        /// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
        pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
 }
+unsafe impl Send for EventHandler {}
+unsafe impl Sync for EventHandler {}
 
 use lightning::util::events::EventHandler as rustEventHandler;
 impl rustEventHandler for EventHandler {
index eddadf6d9fe8a32d6ed30e6989f8d3b3f57fa234..6a21fcbefcaa84d322fc5d8c2f7171ab4b3916cb 100644 (file)
@@ -123,6 +123,8 @@ pub struct Logger {
        /// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
        pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
 }
+unsafe impl Send for Logger {}
+unsafe impl Sync for Logger {}
 
 use lightning::util::logger::Logger as rustLogger;
 impl rustLogger for Logger {
diff --git a/lightning-c-bindings/src/lightning_background_processor.rs b/lightning-c-bindings/src/lightning_background_processor.rs
new file mode 100644 (file)
index 0000000..3900224
--- /dev/null
@@ -0,0 +1,157 @@
+// This file is Copyright its original authors, visible in version control
+// history and in the source files from which this was generated.
+//
+// This file is licensed under the license available in the LICENSE or LICENSE.md
+// file in the root of this repository or, if no such file exists, the same
+// license as that which applies to the original source files from which this
+// source was automatically generated.
+
+//! Utilities that take care of tasks that (1) need to happen periodically to keep Rust-Lightning
+//! running properly, and (2) either can or should be run in the background. See docs for
+//! [`BackgroundProcessor`] for more details on the nitty-gritty.
+
+use std::str::FromStr;
+use std::ffi::c_void;
+use bitcoin::hashes::Hash;
+use crate::c_types::*;
+
+
+use lightning_background_processor::BackgroundProcessor as nativeBackgroundProcessorImport;
+type nativeBackgroundProcessor = nativeBackgroundProcessorImport;
+
+/// BackgroundProcessor takes care of tasks that (1) need to happen periodically to keep
+/// Rust-Lightning running properly, and (2) either can or should be run in the background. Its
+/// responsibilities are:
+/// * Monitoring whether the ChannelManager needs to be re-persisted to disk, and if so,
+///   writing it to disk/backups by invoking the callback given to it at startup.
+///   ChannelManager persistence should be done in the background.
+/// * Calling `ChannelManager::timer_tick_occurred()` and
+///   `PeerManager::timer_tick_occurred()` every minute (can be done in the
+///   background).
+///
+/// Note that if ChannelManager persistence fails and the persisted manager becomes out-of-date,
+/// then there is a risk of channels force-closing on startup when the manager realizes it's
+/// outdated. However, as long as `ChannelMonitor` backups are sound, no funds besides those used
+/// for unilateral chain closure fees are at risk.
+#[must_use]
+#[repr(C)]
+pub struct BackgroundProcessor {
+       /// 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.
+       pub inner: *mut nativeBackgroundProcessor,
+       /// 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.
+       pub is_owned: bool,
+}
+
+impl Drop for BackgroundProcessor {
+       fn drop(&mut self) {
+               if self.is_owned && !<*mut nativeBackgroundProcessor>::is_null(self.inner) {
+                       let _ = unsafe { Box::from_raw(self.inner) };
+               }
+       }
+}
+/// Frees any resources used by the BackgroundProcessor, if is_owned is set and inner is non-NULL.
+#[no_mangle]
+pub extern "C" fn BackgroundProcessor_free(this_obj: BackgroundProcessor) { }
+#[allow(unused)]
+/// Used only if an object of this type is returned as a trait impl by a method
+extern "C" fn BackgroundProcessor_free_void(this_ptr: *mut c_void) {
+       unsafe { let _ = Box::from_raw(this_ptr as *mut nativeBackgroundProcessor); }
+}
+#[allow(unused)]
+/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
+impl BackgroundProcessor {
+       pub(crate) fn take_inner(mut self) -> *mut nativeBackgroundProcessor {
+               assert!(self.is_owned);
+               let ret = self.inner;
+               self.inner = std::ptr::null_mut();
+               ret
+       }
+}
+/// Trait which handles persisting a [`ChannelManager`] to disk.
+///
+/// [`ChannelManager`]: lightning::ln::channelmanager::ChannelManager
+#[repr(C)]
+pub struct ChannelManagerPersister {
+       /// 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.
+       pub this_arg: *mut c_void,
+       /// Persist the given [`ChannelManager`] to disk, returning an error if persistence failed
+       /// (which will cause the [`BackgroundProcessor`] which called this method to exit.
+       ///
+       /// [`ChannelManager`]: lightning::ln::channelmanager::ChannelManager
+       #[must_use]
+       pub persist_manager: extern "C" fn (this_arg: *const c_void, channel_manager: &crate::lightning::ln::channelmanager::ChannelManager) -> crate::c_types::derived::CResult_NoneErrorZ,
+       /// 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.
+       pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
+}
+unsafe impl Send for ChannelManagerPersister {}
+unsafe impl Sync for ChannelManagerPersister {}
+
+use lightning_background_processor::ChannelManagerPersister as rustChannelManagerPersister;
+impl rustChannelManagerPersister<crate::lightning::chain::keysinterface::Sign, crate::lightning::chain::Watch, crate::lightning::chain::chaininterface::BroadcasterInterface, crate::lightning::chain::keysinterface::KeysInterface, crate::lightning::chain::chaininterface::FeeEstimator, crate::lightning::util::logger::Logger> for ChannelManagerPersister {
+       fn persist_manager(&self, mut channel_manager: &lightning::ln::channelmanager::ChannelManager<crate::lightning::chain::keysinterface::Sign, crate::lightning::chain::Watch, crate::lightning::chain::chaininterface::BroadcasterInterface, crate::lightning::chain::keysinterface::KeysInterface, crate::lightning::chain::chaininterface::FeeEstimator, crate::lightning::util::logger::Logger>) -> Result<(), std::io::Error> {
+               let mut ret = (self.persist_manager)(self.this_arg, &crate::lightning::ln::channelmanager::ChannelManager { inner: unsafe { (channel_manager as *const _) as *mut _ }, is_owned: false });
+               let mut local_ret = match ret.result_ok { true => Ok( { () /*(*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.result)) })*/ }), false => Err( { (*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.err)) }).to_rust() })};
+               local_ret
+       }
+}
+
+// We're essentially a pointer already, or at least a set of pointers, so allow us to be used
+// directly as a Deref trait in higher-level structs:
+impl std::ops::Deref for ChannelManagerPersister {
+       type Target = Self;
+       fn deref(&self) -> &Self {
+               self
+       }
+}
+/// Calls the free function if one is set
+#[no_mangle]
+pub extern "C" fn ChannelManagerPersister_free(this_ptr: ChannelManagerPersister) { }
+impl Drop for ChannelManagerPersister {
+       fn drop(&mut self) {
+               if let Some(f) = self.free {
+                       f(self.this_arg);
+               }
+       }
+}
+/// Start a background thread that takes care of responsibilities enumerated in the top-level
+/// documentation.
+///
+/// If `persist_manager` returns an error, then this thread will return said error (and
+/// `start()` will need to be called again to restart the `BackgroundProcessor`). Users should
+/// wait on [`thread_handle`]'s `join()` method to be able to tell if and when an error is
+/// returned, or implement `persist_manager` such that an error is never returned to the
+/// `BackgroundProcessor`
+///
+/// `persist_manager` is responsible for writing out the [`ChannelManager`] to disk, and/or
+/// uploading to one or more backup services. See [`ChannelManager::write`] for writing out a
+/// [`ChannelManager`]. See [`FilesystemPersister::persist_manager`] for Rust-Lightning's
+/// provided implementation.
+///
+/// [`thread_handle`]: BackgroundProcessor::thread_handle
+/// [`ChannelManager`]: lightning::ln::channelmanager::ChannelManager
+/// [`ChannelManager::write`]: lightning::ln::channelmanager::ChannelManager#impl-Writeable
+/// [`FilesystemPersister::persist_manager`]: lightning_persister::FilesystemPersister::persist_manager
+#[must_use]
+#[no_mangle]
+pub extern "C" fn BackgroundProcessor_start(mut persister: crate::lightning_background_processor::ChannelManagerPersister, mut event_handler: crate::lightning::util::events::EventHandler, chain_monitor: &crate::lightning::chain::chainmonitor::ChainMonitor, channel_manager: &crate::lightning::ln::channelmanager::ChannelManager, peer_manager: &crate::lightning::ln::peer_handler::PeerManager, mut logger: crate::lightning::util::logger::Logger) -> BackgroundProcessor {
+       let mut ret = lightning_background_processor::BackgroundProcessor::start(persister, event_handler, unsafe { &*chain_monitor.inner }, unsafe { &*channel_manager.inner }, unsafe { &*peer_manager.inner }, logger);
+       BackgroundProcessor { inner: Box::into_raw(Box::new(ret)), is_owned: true }
+}
+
+/// Stop `BackgroundProcessor`'s thread.
+#[must_use]
+#[no_mangle]
+pub extern "C" fn BackgroundProcessor_stop(mut this_arg: BackgroundProcessor) -> crate::c_types::derived::CResult_NoneErrorZ {
+       let mut ret = (*unsafe { Box::from_raw(this_arg.take_inner()) }).stop();
+       let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { () /*o*/ }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::c_types::IOError::from_rust(e) }).into() };
+       local_ret
+}
+