Regenerate auto-generated bindings

[ldk-c-bindings] / lightning-c-bindings / src / c_types / derived.rs
diff --git a/lightning-c-bindings/src/c_types/derived.rs b/lightning-c-bindings/src/c_types/derived.rs

index 08052dbd2ac72523568cbe534df0f9e318233dac..0e48f5d593518ecc214d76176a09581520060ed4 100644 (file)
--- a/lightning-c-bindings/src/c_types/derived.rs
+++ b/lightning-c-bindings/src/c_types/derived.rs
@@ -1,186 +1,4 @@
  #[repr(C)]
  #[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.
  /// 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 {
  #[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
  #[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)]
  /// 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)]
  }
  #[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`.
  /// `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`.
         /// `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]
         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]
                 },
                 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]
                 },
                 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 {
         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 {
                 } 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 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 {
                 } 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,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                         } }
                 }
         }
  }
  #[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.
  /// 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)]
  #[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.
         /// 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)]
  }
  #[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`.
  /// `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`.
         /// `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]
         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]
                         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]
                 },
                 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 {
         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() };
                 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 {
                 } 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,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                         } }
                 }
         }
  }
  #[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.
  /// 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)]
  #[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]
         }
  }
  #[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) {
         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 {
         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)]
  #[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++
  /// 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().
         /// 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
  }
         /// 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
         }
                 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) }
         }
  }
                 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() } }
                 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.
  }
  #[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)) };
         }
  }
         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); }
         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)]
         }
  }
  #[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)]
  }
  #[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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_PayeePubKeyErrorZPtr { err }
+                       CResult_RouteDecodeErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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)]
  #[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++
  /// 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().
         /// 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
  }
         /// 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
         }
                 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) }
         }
  }
                 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() } }
                 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.
  }
  #[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)) };
         }
  }
         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); }
         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)]
         }
  }
  #[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]
  }
  #[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)]
  #[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.
         /// 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.
         /// 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)]
  }
  #[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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_PositiveTimestampCreationErrorZPtr { err }
+                       CResult_RouteLightningErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                         } }
                 }
         }
  }
  #[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.
  /// 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)]
  #[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.
         /// 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)]
  }
  #[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`.
  /// `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`.
         /// `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]
         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]
                 },
                 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]
                         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 {
         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) };
                 } 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 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_NoneSemanticErrorZPtr { err }
+                       CResult_TxOutAccessErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                         } }
                 }
         }
  }
  #[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.
  /// 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)]
  #[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 {
         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]
                 }
         }
  }
  #[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.
  /// 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)]
  #[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]
         }
  }
  #[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]
         }
  }
  #[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)]
  #[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.
         /// 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)]
  }
  #[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`.
  /// `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`.
         /// `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]
         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]
                 },
                 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]
                         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 {
         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) };
                 } 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 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_ExpiryTimeCreationErrorZPtr { err }
+                       CResult_NoneChannelMonitorUpdateErrZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                         } }
                 }
         }
  }
  #[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.
  /// 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)]
  #[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++
  /// 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().
         /// 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
  }
         /// 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
         }
                 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) }
         }
  }
                 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() } }
                 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.
  }
  #[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)) };
         }
  }
         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); }
         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)]
         }
  }
  #[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]
         }
  }
  #[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]
  }
  #[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 {
         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]
         }
  }
  #[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)]
  #[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.
         /// 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.
         /// 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)]
  }
  #[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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_StringErrorZPtr { err }
+                       CResult_InitFeaturesDecodeErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 Self {
                         contents,
@@ -2524,50 +2356,50 @@ impl From<crate::c_types::CResultTempl<crate::c_types::Str, crate::c_types::Secp
         }
  }
  #[repr(C)]
         }
  }
  #[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.
         /// 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 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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_ChannelMonitorUpdateDecodeErrorZPtr { err }
+                       CResult_NodeFeaturesDecodeErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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)]
  #[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.
         /// 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 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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_HTLCUpdateDecodeErrorZPtr { err }
+                       CResult_ChannelFeaturesDecodeErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
                 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 {
                 } 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)]
  #[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.
         /// 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)]
  }
  #[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`.
  /// `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`.
         /// `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]
         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]
                 },
                 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]
                         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 {
         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) };
                 } 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 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_NoneMonitorUpdateErrorZPtr { err }
+                       CResult_DelayedPaymentOutputDescriptorDecodeErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                         } }
                 }
         }
  }
  #[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.
  /// 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)]
  #[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 {
                 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 {
         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]
                 }
         }
  }
  #[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.
  /// 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)]
  #[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]
         }
  }
  #[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) {
         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 {
         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.
  #[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
         /// The element at position 0
-       pub a: crate::c_types::ThirtyTwoBytes,
+       pub a: crate::c_types::Signature,
         /// The element at position 1
         /// 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,
                 }
         }
  }
                 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)
         }
  }
                 (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]
  #[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]
  }
  
  #[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)]
  #[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]
  }
  #[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]
         }
  }
  #[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]
         }
  }
  #[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) {
         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 {
                 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]
  #[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)]
  #[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]
         }
  }
  #[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) {
         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 {
                 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 {
         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]
                 }
         }
  }
  #[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.
  /// 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)]
  #[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]
         }
  }
  #[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) {
         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 {
                 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]
  #[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)]
  #[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++
  /// 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().
         /// 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
  }
         /// 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
         }
                 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) }
         }
  }
                 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() } }
                 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.
  }
  #[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)) };
         }
  }
         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)]
         }
  }
  #[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)]
  }
  #[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`.
  /// `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`.
         /// `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]
         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]
                 },
                 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]
                 },
                 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 {
         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 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 {
                 } 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,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                         } }
                 }
         }
  }
  #[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.
  /// 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)]
  #[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]
  #[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)]
  #[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.
         /// 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)]
  }
  #[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`.
  /// `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`.
         /// `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]
         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]
                         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]
                 },
                 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 {
         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() };
                 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 {
                 } 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,
                 };
                 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)]
  #[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.
         /// 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 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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_RouteHopDecodeErrorZPtr { err }
+                       CResult_InMemorySignerDecodeErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                                 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.
  /// 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)]
  #[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++
  /// 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().
         /// 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
  }
         /// 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
         }
                 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) }
         }
  }
                 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() } }
                 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.
  }
  #[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)) };
         }
  }
         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); }
         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)]
         }
  }
  #[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++
  /// 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().
         /// 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
  }
         /// 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
         }
                 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) }
         }
  }
                 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() } }
                 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.
  }
  #[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)) };
         }
  }
         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)]
  #[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.
         /// 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.
         /// 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)]
  }
  #[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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } 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,
                 };
                 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)]
  #[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.
         /// 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)]
  }
  #[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`.
  /// `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`.
         /// `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]
         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]
                 },
                 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]
                         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 {
         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) };
                 } 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 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_RouteLightningErrorZPtr { err }
+                       CResult_NoneAPIErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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)]
  #[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++
  /// 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().
         /// 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
  }
         /// 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
         }
                 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) }
         }
  }
                 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() } }
                 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.
  }
  #[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)) };
         }
  }
         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); }
         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)]
         }
  }
  #[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.
         /// 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)]
  }
  #[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`.
  /// `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`.
         /// `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]
         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]
                 },
                 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]
                         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 {
         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) };
                 } 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 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_boolLightningErrorZPtr { err }
+                       CResult_NonePaymentSendFailureZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                         } }
                 }
         }
  }
  #[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.
  /// 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)]
  #[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++
  /// 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().
         /// 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
  }
         /// 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
         }
                 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) }
         }
  }
                 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() } }
                 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.
  }
  #[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)) };
         }
  }
         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); }
         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)]
         }
  }
  #[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 {
         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)]
  #[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.
         /// 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)]
  }
  #[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`.
  /// `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`.
         /// `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]
         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]
                 },
                 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]
                         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 {
         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) };
                 } 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 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_NoneLightningErrorZPtr { err }
+                       CResult_PaymentSecretAPIErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                         } }
                 }
         }
  }
  #[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.
  /// 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)]
  #[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++
  /// 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().
         /// 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
  }
         /// 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
         }
                 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) }
         }
  }
                 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() } }
                 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.
  }
  #[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)]
         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.
         /// 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.
         /// 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)]
  }
  #[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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } 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,
                 };
                 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)]
  #[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.
         /// 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)]
  }
  #[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`.
  /// `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`.
         /// `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]
         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]
                 },
                 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]
                         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 {
         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) };
                 } 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 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_NonePeerHandleErrorZPtr { err }
+                       CResult_ChannelConfigDecodeErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                         } }
                 }
         }
  }
  #[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.
  /// 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)]
  #[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.
         /// 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.
         /// 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)]
  }
  #[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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_boolPeerHandleErrorZPtr { err }
+                       CResult_OutPointDecodeErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                         } }
                 }
         }
  }
  #[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.
  /// 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)]
  #[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.
         /// 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)]
  }
  #[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`.
  /// `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`.
         /// `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]
         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]
                         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]
                 },
                 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 {
         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() };
                 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 {
                 } 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,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                         } }
                 }
         }
  }
  #[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.
  /// 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)]
  #[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.
         /// 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)]
  }
  #[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`.
  /// `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`.
         /// `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]
         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]
                         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]
                 },
                 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 {
         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() };
                 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 {
                 } 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,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                         } }
                 }
         }
  }
  #[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.
  /// 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)]
  #[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.
         /// 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)]
  }
  #[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`.
  /// `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`.
         /// `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]
         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]
                         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]
                 },
                 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 {
         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() };
                 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 {
                 } 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,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                         } }
                 }
         }
  }
  #[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.
  /// 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)]
  #[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.
         /// 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.
         /// 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)]
  }
  #[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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_RoutingFeesDecodeErrorZPtr { err }
+                       CResult_PayeePubKeyErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                         } }
                 }
         }
  }
  #[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.
  /// 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)]
  #[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++
  /// 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().
         /// 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
  }
         /// 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
         }
                 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) }
         }
  }
                 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() } }
                 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.
  }
  #[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)) };
         }
  }
         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); }
         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)]
         }
  }
  #[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.
         /// 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.
         /// 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)]
  }
  #[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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_NodeAnnouncementInfoDecodeErrorZPtr { err }
+                       CResult_PositiveTimestampCreationErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                         } }
                 }
         }
  }
  #[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.
  /// 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)]
  #[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]
         }
  }
  #[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) {
         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 {
         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)]
  #[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.
         /// 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.
         /// 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)]
  }
  #[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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_NodeInfoDecodeErrorZPtr { err }
+                       CResult_InvoiceSemanticErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                         } }
                 }
         }
  }
  #[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.
  /// 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)]
  #[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.
         /// 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.
         /// 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)]
  }
  #[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`.
  /// `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`.
         /// `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,
  }
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_NetworkGraphDecodeErrorZPtr { err }
+                       CResult_DescriptionCreationErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                         } }
                 }
         }
  }
  #[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.
  /// 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)]
  #[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.
         /// 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.
         /// 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)]
  }
  #[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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_InitFeaturesDecodeErrorZPtr { err }
+                       CResult_ExpiryTimeCreationErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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)]
  #[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.
         /// 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.
         /// 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)]
  }
  #[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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_NodeFeaturesDecodeErrorZPtr { err }
+                       CResult_RouteHintCreationErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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)]
  #[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.
         /// 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.
         /// 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)]
  }
  #[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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_ChannelFeaturesDecodeErrorZPtr { err }
+                       CResult_StringErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 Self {
                         contents,
@@ -5680,50 +5619,50 @@ impl From<crate::c_types::CResultTempl<crate::lightning::ln::features::ChannelFe
         }
  }
  #[repr(C)]
         }
  }
  #[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.
         /// 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 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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_InvoiceFeaturesDecodeErrorZPtr { err }
+                       CResult_ChannelMonitorUpdateDecodeErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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)]
  #[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.
         /// 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.
         /// 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)]
  }
  #[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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_NetAddressu8ZPtr { err }
+                       CResult_HTLCUpdateDecodeErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                         } }
                 }
         }
  }
  #[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.
  /// 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)]
  #[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.
         /// 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)]
  }
  #[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`.
  /// `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`.
         /// `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]
         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]
                 },
                 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]
                         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 {
         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) };
                 } 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 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_CResult_NetAddressu8ZDecodeErrorZPtr { err }
+                       CResult_NoneMonitorUpdateErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                         } }
                 }
         }
  }
  #[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.
  /// 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)]
  #[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)]
  #[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]
         }
  }
  #[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) {
         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 {
                 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 {
         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]
                 }
         }
  }
  #[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.
  /// 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)]
  #[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++
  /// 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().
         /// 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
  }
         /// 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
         }
                 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) }
         }
  }
                 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() } }
                 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.
  }
  #[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)) };
         }
  }
         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); }
         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)]
         }
  }
  #[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++
  /// 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().
         /// 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
  }
         /// 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
         }
                 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) }
         }
  }
                 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() } }
                 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.
  }
  #[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)) };
         }
  }
         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); }
         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)]
         }
  }
  #[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++
  /// 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().
         /// 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
  }
         /// 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
         }
                 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) }
         }
  }
                 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() } }
                 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.
  }
  #[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)) };
         }
  }
         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); }
         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)]
         }
  }
  #[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++
  /// 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().
         /// 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
  }
         /// 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
         }
                 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) }
         }
                 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() } }
                 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.
  }
  #[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)) };
         }
  }
         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); }
         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)]
         }
  }
  #[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 {
         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]
                 }
         }
  }
  #[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.
  /// 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)]
  #[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]
         }
  }
  #[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) {
         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 {
         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)]
  #[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.
         /// 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 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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_ChannelReestablishDecodeErrorZPtr { err }
+                       CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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)]
  #[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.
         /// 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.
         /// 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)]
  }
  #[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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_ClosingSignedDecodeErrorZPtr { err }
+                       CResult_boolLightningErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                         } }
                 }
         }
  }
  #[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.
  /// 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)]
  #[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.
         /// 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)]
  }
  #[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`.
  /// `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`.
         /// `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]
         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]
                 },
                 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]
                         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 {
         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) };
                 } 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 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_CommitmentSignedDecodeErrorZPtr { err }
+                       CResult_NoneLightningErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                         } }
                 }
         }
  }
  #[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.
  /// 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)]
  #[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.
         /// 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.
         /// 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)]
  }
  #[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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_FundingCreatedDecodeErrorZPtr { err }
+                       CResult_CVec_u8ZPeerHandleErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                         } }
                 }
         }
  }
  #[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.
  /// 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)]
  #[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.
         /// 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)]
  }
  #[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`.
  /// `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`.
         /// `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]
         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]
                 },
                 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]
                         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 {
         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) };
                 } 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 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_FundingSignedDecodeErrorZPtr { err }
+                       CResult_NonePeerHandleErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                         } }
                 }
         }
  }
  #[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.
  /// 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)]
  #[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.
         /// 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.
         /// 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)]
  }
  #[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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_FundingLockedDecodeErrorZPtr { err }
+                       CResult_boolPeerHandleErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                         } }
                 }
         }
  }
  #[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.
  /// 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)]
  #[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.
         /// 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 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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_InitDecodeErrorZPtr { err }
+                       CResult_DirectionalChannelInfoDecodeErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                                 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.
  /// 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)]
  #[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.
         /// 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 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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_OpenChannelDecodeErrorZPtr { err }
+                       CResult_ChannelInfoDecodeErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                                 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.
  /// 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)]
  #[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.
         /// 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 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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_RevokeAndACKDecodeErrorZPtr { err }
+                       CResult_RoutingFeesDecodeErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                                 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.
  /// 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)]
  #[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.
         /// 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 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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_ShutdownDecodeErrorZPtr { err }
+                       CResult_NodeAnnouncementInfoDecodeErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                                 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.
  /// 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)]
  #[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.
         /// 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 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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_UpdateFailHTLCDecodeErrorZPtr { err }
+                       CResult_NodeInfoDecodeErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                                 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.
  /// 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)]
  #[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.
         /// 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 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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_UpdateFailMalformedHTLCDecodeErrorZPtr { err }
+                       CResult_NetworkGraphDecodeErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                                 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.
  /// 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)]
  #[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.
         /// 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.
         /// 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)]
  }
  #[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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_UpdateFeeDecodeErrorZPtr { err }
+                       CResult_NetAddressu8ZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                         } }
                 }
         }
  }
  #[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.
  /// 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)]
  #[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.
         /// 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 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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_UpdateFulfillHTLCDecodeErrorZPtr { err }
+                       CResult_CResult_NetAddressu8ZDecodeErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                                 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.
  /// 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)]
  #[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.
         /// 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 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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_UpdateAddHTLCDecodeErrorZPtr { err }
+                       CResult_NetAddressDecodeErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                                 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.
  /// 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)]
  #[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)]
  }
  #[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]
         }
  }
  #[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) {
         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 {
         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)]
  #[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.
         /// 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 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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_PongDecodeErrorZPtr { err }
+                       CResult_AcceptChannelDecodeErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                                 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.
  /// 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)]
  #[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.
         /// 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 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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_UnsignedChannelAnnouncementDecodeErrorZPtr { err }
+                       CResult_AnnouncementSignaturesDecodeErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                                 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.
  /// 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)]
  #[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.
         /// 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 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`.
  /// `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`.
         /// `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,
  }
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_ChannelAnnouncementDecodeErrorZPtr { err }
+                       CResult_ChannelReestablishDecodeErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                                 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.
  /// 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)]
  #[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.
         /// 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 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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_UnsignedChannelUpdateDecodeErrorZPtr { err }
+                       CResult_ClosingSignedDecodeErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                                 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.
  /// 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)]
  #[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.
         /// 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 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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_ChannelUpdateDecodeErrorZPtr { err }
+                       CResult_CommitmentSignedDecodeErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                                 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.
  /// 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)]
  #[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.
         /// 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 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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_ErrorMessageDecodeErrorZPtr { err }
+                       CResult_FundingCreatedDecodeErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                                 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.
  /// 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)]
  #[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.
         /// 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 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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_UnsignedNodeAnnouncementDecodeErrorZPtr { err }
+                       CResult_FundingSignedDecodeErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                                 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.
  /// 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)]
  #[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.
         /// 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 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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_NodeAnnouncementDecodeErrorZPtr { err }
+                       CResult_FundingLockedDecodeErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                                 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.
  /// 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)]
  #[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.
         /// 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 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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_QueryShortChannelIdsDecodeErrorZPtr { err }
+                       CResult_InitDecodeErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                                 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.
  /// 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)]
  #[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.
         /// 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 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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_ReplyShortChannelIdsEndDecodeErrorZPtr { err }
+                       CResult_OpenChannelDecodeErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                                 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.
  /// 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)]
  #[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.
         /// 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 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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_QueryChannelRangeDecodeErrorZPtr { err }
+                       CResult_RevokeAndACKDecodeErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                                 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.
  /// 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)]
  #[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.
         /// 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 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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_ReplyChannelRangeDecodeErrorZPtr { err }
+                       CResult_ShutdownDecodeErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                                 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.
  /// 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)]
  #[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.
         /// 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 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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_GossipTimestampFilterDecodeErrorZPtr { err }
+                       CResult_UpdateFailHTLCDecodeErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                                 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.
  /// 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)]
  #[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.
         /// 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.
         /// 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)]
  }
  #[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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_InvoiceSignOrCreationErrorZPtr { err }
+                       CResult_UpdateFailMalformedHTLCDecodeErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                         } }
                 }
         }
  }
  #[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.
  /// 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)]
  #[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.
         /// 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 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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_DelayedPaymentOutputDescriptorDecodeErrorZPtr { err }
+                       CResult_UpdateFeeDecodeErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                                 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.
  /// 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)]
  #[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.
         /// 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 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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_StaticPaymentOutputDescriptorDecodeErrorZPtr { err }
+                       CResult_UpdateFulfillHTLCDecodeErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                                 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.
  /// 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)]
  #[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.
         /// 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 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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_SpendableOutputDescriptorDecodeErrorZPtr { err }
+                       CResult_UpdateAddHTLCDecodeErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                                 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.
  /// 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)]
  #[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.
         /// 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)]
  }
  #[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`.
  /// `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`.
         /// `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]
         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]
                         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]
                 },
                 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 {
         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() };
                 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 {
                 } 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,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                         } }
                 }
         }
  }
  #[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.
  /// 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)]
  #[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.
         /// 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)]
  }
  #[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`.
  /// `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`.
         /// `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]
         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]
                         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]
                 },
                 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 {
         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() };
                 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 {
                 } 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,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                         } }
                 }
         }
  }
  #[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.
  /// 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)]
  #[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.
         /// 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 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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_SignDecodeErrorZPtr { err }
+                       CResult_UnsignedChannelAnnouncementDecodeErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                                 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.
  /// 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)]
  #[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.
         /// 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)]
  }
  #[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`.
  /// `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`.
         /// `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]
         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]
                         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]
                 },
                 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 {
         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() };
                 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 {
                 } 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,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                         } }
                 }
         }
  }
  #[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.
  /// 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)]
  #[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 {
         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)]
  #[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.
         /// 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)]
  }
  #[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`.
  /// `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`.
         /// `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]
         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]
                         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]
                 },
                 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 {
         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() };
                 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 {
                 } 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,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                         } }
                 }
         }
  }
  #[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.
  /// 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)]
  #[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.
         /// 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 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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_InMemorySignerDecodeErrorZPtr { err }
+                       CResult_ErrorMessageDecodeErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                                 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.
  /// 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)]
  #[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 {
         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)]
  #[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.
         /// 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)]
  }
  #[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`.
  /// `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`.
         /// `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]
         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]
                         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]
                 },
                 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 {
         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() };
                 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 {
                 } 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,
                 };
                 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)]
  #[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.
         /// 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)]
  }
  #[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`.
  /// `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`.
         /// `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]
         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]
                 },
                 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]
                         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 {
         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) };
                 } 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 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_NoneErrorZPtr { err }
+                       CResult_QueryShortChannelIdsDecodeErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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]
         }
  }
  #[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)]
  #[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.
         /// 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.
         /// 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)]
  }
  #[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`.
  /// `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`.
         /// `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,
  }
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } 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,
                 };
                 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)]
  #[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.
         /// 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)]
  }
  #[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`.
  /// `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`.
         /// `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]
         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]
                 },
                 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]
                         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 {
         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) };
                 } 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 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_NoneAPIErrorZPtr { err }
+                       CResult_QueryChannelRangeDecodeErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                         } }
                 }
         }
  }
  #[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.
  /// 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)]
  #[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.
         /// 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)]
  }
  #[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`.
  /// `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`.
         /// `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]
         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]
                 },
                 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]
                         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 {
         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) };
                 } 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 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_NonePaymentSendFailureZPtr { err }
+                       CResult_ReplyChannelRangeDecodeErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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 {
         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 {
                         } }
                 } 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]
                         } }
                 }
         }
  }
  #[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.
  /// 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)]
  #[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.
         /// 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.
         /// 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)]
  }
  #[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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_PaymentSecretAPIErrorZPtr { err }
+                       CResult_GossipTimestampFilterDecodeErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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]
  #[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)]
  #[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.
         /// 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.
         /// 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)]
  }
  #[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`.
  /// `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`.
         /// `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]
         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]
                         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]
                         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() } {
         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() };
                 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(); }
                 } else {
                         let err = unsafe { o.contents.err };
                         unsafe { o.contents.err = std::ptr::null_mut(); }
-                       CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZPtr { err }
+                       CResult_InvoiceSignOrCreationErrorZPtr { err }
                 };
                 Self {
                         contents,
                 };
                 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() }