X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning-c-bindings%2Finclude%2Flightningpp.hpp;h=544d53170e3650ef3ce26defdb150a5efc0c7074;hb=a21177846ed75d66f68a1603f768410f07a65791;hp=1b383c094ef84d04f9c2694795496e86f793b4b0;hpb=1c42b239702f5435607e605fca91fe0f945afecf;p=ldk-c-bindings

diff --git a/lightning-c-bindings/include/lightningpp.hpp b/lightning-c-bindings/include/lightningpp.hpp
index 1b383c0..544d531 100644
--- a/lightning-c-bindings/include/lightningpp.hpp
+++ b/lightning-c-bindings/include/lightningpp.hpp
@@ -2,6 +2,8 @@
 namespace LDK {
 // Forward declarations
 class Str;
+class BlindedRoute;
+class BlindedHop;
 class CounterpartyCommitmentSecrets;
 class TxCreationKeys;
 class ChannelPublicKeys;
@@ -30,9 +32,11 @@ class ConfirmationTarget;
 class FeeEstimator;
 class PaymentPurpose;
 class ClosureReason;
+class HTLCDestination;
 class Event;
 class MessageSendEvent;
 class MessageSendEventsProvider;
+class OnionMessageProvider;
 class EventsProvider;
 class EventHandler;
 class BestBlock;
@@ -40,13 +44,15 @@ class AccessError;
 class Access;
 class Listen;
 class Confirm;
-class ChannelMonitorUpdateErr;
+class ChannelMonitorUpdateStatus;
 class Watch;
 class Filter;
 class WatchedOutput;
 class Score;
 class LockableScore;
+class WriteableScore;
 class MultiThreadedLockableScore;
+class MultiThreadedScoreLock;
 class ChannelUsage;
 class FixedPenaltyScorer;
 class ProbabilisticScorer;
@@ -56,6 +62,7 @@ class NodeFeatures;
 class ChannelFeatures;
 class InvoiceFeatures;
 class ChannelTypeFeatures;
+class CustomOnionMessageContents;
 class NodeId;
 class NetworkGraph;
 class ReadOnlyNetworkGraph;
@@ -94,6 +101,7 @@ class ChannelConfig;
 class UserConfig;
 class APIError;
 class BigSize;
+class Hostname;
 class OutPoint;
 class CustomMessageReader;
 class Type;
@@ -102,6 +110,7 @@ class Payer;
 class Router;
 class Retry;
 class PaymentError;
+class InFlightHtlcs;
 class ParseError;
 class ParseOrSemanticError;
 class Invoice;
@@ -135,6 +144,10 @@ class MessageHandler;
 class SocketDescriptor;
 class PeerHandleError;
 class PeerManager;
+class OnionMessenger;
+class Destination;
+class SendError;
+class CustomOnionMessageHandler;
 class RapidGossipSync;
 class Persister;
 class DecodeError;
@@ -152,6 +165,7 @@ class Shutdown;
 class ClosingSignedFeeRange;
 class ClosingSigned;
 class UpdateAddHTLC;
+class OnionMessage;
 class UpdateFulfillHTLC;
 class UpdateFailHTLC;
 class UpdateFailMalformedHTLC;
@@ -178,11 +192,14 @@ class LightningError;
 class CommitmentUpdate;
 class ChannelMessageHandler;
 class RoutingMessageHandler;
+class OnionMessageHandler;
 class GraphSyncError;
 class DefaultRouter;
 class Level;
 class Record;
 class Logger;
+class FutureCallback;
+class Future;
 class MonitorUpdateId;
 class Persist;
 class LockedChannelMonitor;
@@ -197,10 +214,12 @@ class CResult_HTLCUpdateDecodeErrorZ;
 class C2Tuple_SignatureCVec_SignatureZZ;
 class CVec_C2Tuple_u32TxOutZZ;
 class CResult_ChannelInfoDecodeErrorZ;
+class COption_WriteableScoreZ;
+class CResult_NoneSendErrorZ;
 class CResult_FundingCreatedDecodeErrorZ;
 class CResult_ChannelAnnouncementDecodeErrorZ;
-class CVec_OutPointZ;
 class CResult_PositiveTimestampCreationErrorZ;
+class CVec_OutPointZ;
 class CResult_CVec_u8ZPeerHandleErrorZ;
 class CResult_InvoiceFeaturesDecodeErrorZ;
 class COption_NetworkUpdateZ;
@@ -212,27 +231,28 @@ class CResult_ChannelMonitorUpdateDecodeErrorZ;
 class CResult_RouteHintDecodeErrorZ;
 class C2Tuple_PublicKeyTypeZ;
 class CResult_NetAddressDecodeErrorZ;
+class COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ;
 class CResult_ChannelReestablishDecodeErrorZ;
-class CResult_CommitmentSignedDecodeErrorZ;
 class CVec_UpdateAddHTLCZ;
-class CResult_UnsignedNodeAnnouncementDecodeErrorZ;
+class CResult_CommitmentSignedDecodeErrorZ;
 class COption_u32Z;
 class CResult_InitFeaturesDecodeErrorZ;
 class CResult_StaticPaymentOutputDescriptorDecodeErrorZ;
+class CResult_PublicKeyNoneZ;
 class CResult_PaymentIdPaymentSendFailureZ;
-class CResult_ReplyChannelRangeDecodeErrorZ;
 class CResult_CommitmentTransactionDecodeErrorZ;
-class COption_C2Tuple_usizeTransactionZZ;
 class CResult_TransactionNoneZ;
 class CResult_ClosingSignedFeeRangeDecodeErrorZ;
+class CResult_OnionMessageDecodeErrorZ;
 class CResult_PingDecodeErrorZ;
+class CResult_UnsignedNodeAnnouncementDecodeErrorZ;
+class CResult_ReplyChannelRangeDecodeErrorZ;
 class CResult_GossipTimestampFilterDecodeErrorZ;
-class CResult_InvoiceSignOrCreationErrorZ;
-class COption_FilterZ;
 class CVec_TransactionOutputsZ;
 class CResult_ErrorMessageDecodeErrorZ;
 class CResult_OpenChannelDecodeErrorZ;
 class CVec_CVec_u8ZZ;
+class CResult_COption_CustomOnionMessageContentsZDecodeErrorZ;
 class CResult_SecretKeyErrorZ;
 class CResult_ShutdownScriptDecodeErrorZ;
 class CResult_ProbabilisticScorerDecodeErrorZ;
@@ -250,28 +270,32 @@ class CVec_BalanceZ;
 class CResult_HTLCOutputInCommitmentDecodeErrorZ;
 class CResult_boolLightningErrorZ;
 class CResult_TxCreationKeysErrorZ;
+class COption_HTLCDestinationZ;
 class CResult_NodeIdDecodeErrorZ;
-class C2Tuple_BlockHashChannelMonitorZ;
 class CResult_ShutdownScriptInvalidShutdownScriptZ;
 class CResult_NodeAnnouncementInfoDecodeErrorZ;
 class CResult_COption_NetworkUpdateZDecodeErrorZ;
 class CResult_RecoverableSignatureNoneZ;
+class C2Tuple_BlockHashChannelMonitorZ;
 class C3Tuple_RawInvoice_u832InvoiceSignatureZ;
 class CVec_UpdateFailMalformedHTLCZ;
 class CResult_FundingSignedDecodeErrorZ;
 class CResult_NetworkGraphDecodeErrorZ;
+class CResult_InvoiceSignOrCreationErrorZ;
 class CVec_RouteHopZ;
-class CResult_NonePaymentSendFailureZ;
+class COption_FilterZ;
+class COption_CustomOnionMessageContentsZ;
 class CResult_NodeInfoDecodeErrorZ;
+class CVec_NodeIdZ;
 class CResult_RouteLightningErrorZ;
 class CResult_ChannelPublicKeysDecodeErrorZ;
-class CVec_NodeIdZ;
 class CVec_u8Z;
 class CVec_C2Tuple_BlockHashChannelMonitorZZ;
+class CResult_NonePaymentSendFailureZ;
 class CVec_ThirtyTwoBytesZ;
 class CResult_ClosingSignedDecodeErrorZ;
-class CResult_HolderCommitmentTransactionDecodeErrorZ;
 class CVec_CResult_NoneAPIErrorZZ;
+class CResult_HolderCommitmentTransactionDecodeErrorZ;
 class CResult_CounterpartyCommitmentSecretsDecodeErrorZ;
 class CResult_ChannelCounterpartyDecodeErrorZ;
 class CResult_WarningMessageDecodeErrorZ;
@@ -284,22 +308,21 @@ class CResult_PaymentParametersDecodeErrorZ;
 class CResult_PaymentPurposeDecodeErrorZ;
 class CResult_InitDecodeErrorZ;
 class CResult_OutPointDecodeErrorZ;
+class CResult_BlindedRouteDecodeErrorZ;
 class CVec_ChannelDetailsZ;
-class CResult_SignDecodeErrorZ;
-class C2Tuple_OutPointCVec_MonitorEventZZ;
 class CVec_MessageSendEventZ;
+class CResult_SignDecodeErrorZ;
 class COption_NetAddressZ;
 class C2Tuple_OutPointScriptZ;
 class CResult_RouteHintHopDecodeErrorZ;
 class CResult_C2Tuple_SignatureSignatureZNoneZ;
-class CVec_NodeAnnouncementZ;
 class CResult_UpdateFailMalformedHTLCDecodeErrorZ;
-class CResult_UnsignedChannelAnnouncementDecodeErrorZ;
+class CResult_SharedSecretNoneZ;
 class CVec_TxidZ;
 class COption_AccessZ;
 class CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ;
-class CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ;
 class CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ;
+class CResult_PongDecodeErrorZ;
 class CResult_CVec_CVec_u8ZZNoneZ;
 class C2Tuple_SignatureSignatureZ;
 class C2Tuple_PaymentHashPaymentSecretZ;
@@ -308,19 +331,22 @@ class CResult_ChannelTransactionParametersDecodeErrorZ;
 class CResult_AcceptChannelDecodeErrorZ;
 class CVec_SignatureZ;
 class CVec_u64Z;
-class CResult_PongDecodeErrorZ;
+class CResult_UnsignedChannelAnnouncementDecodeErrorZ;
 class CResult_DelayedPaymentOutputDescriptorDecodeErrorZ;
 class C2Tuple_PaymentHashPaymentIdZ;
 class CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ;
 class CResult_NoneErrorZ;
+class CResult_COption_HTLCDestinationZDecodeErrorZ;
+class CResult_InFlightHtlcsDecodeErrorZ;
 class CResult_StringErrorZ;
-class C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ;
 class CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ;
 class COption_EventZ;
+class C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ;
 class CResult_ChannelTypeFeaturesDecodeErrorZ;
 class CResult_SiPrefixParseErrorZ;
 class CVec_RouteHintZ;
 class COption_u16Z;
+class CResult_BlindedHopDecodeErrorZ;
 class CVec_CVec_RouteHopZZ;
 class CResult_TrustedCommitmentTransactionNoneZ;
 class CResult_FixedPenaltyScorerDecodeErrorZ;
@@ -335,17 +361,18 @@ class CResult_DescriptionCreationErrorZ;
 class CResult_RoutingFeesDecodeErrorZ;
 class CResult_PayeePubKeyErrorZ;
 class CResult_COption_MonitorEventZDecodeErrorZ;
+class C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ;
 class CVec_C2Tuple_PublicKeyTypeZZ;
-class CResult_u32GraphSyncErrorZ;
 class CResult_InvoiceSemanticErrorZ;
+class CResult_u32GraphSyncErrorZ;
 class CResult_UpdateAddHTLCDecodeErrorZ;
-class CResult_QueryShortChannelIdsDecodeErrorZ;
 class CResult_CounterpartyChannelTransactionParametersDecodeErrorZ;
 class CResult_NoneAPIErrorZ;
 class CVec_NetAddressZ;
 class CResult_ChannelDetailsDecodeErrorZ;
 class CVec_PublicKeyZ;
 class CVec_C2Tuple_usizeTransactionZZ;
+class CResult_QueryShortChannelIdsDecodeErrorZ;
 class CVec_PhantomRouteHintsZ;
 class COption_MonitorEventZ;
 class C2Tuple_u64u64Z;
@@ -366,9 +393,9 @@ class CResult_NoneSemanticErrorZ;
 class CVec_MonitorEventZ;
 class CVec_PaymentPreimageZ;
 class CVec_C2Tuple_u32ScriptZZ;
-class CResult_NoneChannelMonitorUpdateErrZ;
 class CResult_COption_ClosureReasonZDecodeErrorZ;
 class CResult_PublicKeyErrorZ;
+class CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ;
 class C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ;
 class CResult_NoneNoneZ;
 class CResult_RouteParametersDecodeErrorZ;
@@ -378,6 +405,7 @@ class CVec_APIErrorZ;
 class CResult_PrivateRouteCreationErrorZ;
 class CResult_boolPeerHandleErrorZ;
 class CVec_UpdateFulfillHTLCZ;
+class CResult_BlindedRouteNoneZ;
 class CResult_AnnouncementSignaturesDecodeErrorZ;
 class CResult_UpdateFulfillHTLCDecodeErrorZ;
 class CResult_ChannelUpdateDecodeErrorZ;
@@ -386,14 +414,14 @@ class CVec_u5Z;
 class CResult_InMemorySignerDecodeErrorZ;
 class CResult_PaymentSecretAPIErrorZ;
 class CResult_CounterpartyForwardingInfoDecodeErrorZ;
+class COption_ScalarZ;
 class CResult_SignedRawInvoiceParseErrorZ;
-class C2Tuple_u32ScriptZ;
 class CResult_RouteDecodeErrorZ;
 class CResult_BuiltCommitmentTransactionDecodeErrorZ;
 class COption_NoneZ;
 class CVec_TxOutZ;
 class CResult_ChannelUpdateInfoDecodeErrorZ;
-class CVec_C2Tuple_OutPointCVec_MonitorEventZZZ;
+class C2Tuple_u32ScriptZ;
 class CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ;
 class CVec_UpdateFailHTLCZ;
 class CResult_ReplyShortChannelIdsEndDecodeErrorZ;
@@ -413,6 +441,36 @@ public:
 	const LDKStr* operator &() const { return &self; }
 	const LDKStr* operator ->() const { return &self; }
 };
+class BlindedRoute {
+private:
+	LDKBlindedRoute self;
+public:
+	BlindedRoute(const BlindedRoute&) = delete;
+	BlindedRoute(BlindedRoute&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedRoute)); }
+	BlindedRoute(LDKBlindedRoute&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedRoute)); }
+	operator LDKBlindedRoute() && { LDKBlindedRoute res = self; memset(&self, 0, sizeof(LDKBlindedRoute)); return res; }
+	~BlindedRoute() { BlindedRoute_free(self); }
+	BlindedRoute& operator=(BlindedRoute&& o) { BlindedRoute_free(self); self = o.self; memset(&o, 0, sizeof(BlindedRoute)); return *this; }
+	LDKBlindedRoute* operator &() { return &self; }
+	LDKBlindedRoute* operator ->() { return &self; }
+	const LDKBlindedRoute* operator &() const { return &self; }
+	const LDKBlindedRoute* operator ->() const { return &self; }
+};
+class BlindedHop {
+private:
+	LDKBlindedHop self;
+public:
+	BlindedHop(const BlindedHop&) = delete;
+	BlindedHop(BlindedHop&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedHop)); }
+	BlindedHop(LDKBlindedHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedHop)); }
+	operator LDKBlindedHop() && { LDKBlindedHop res = self; memset(&self, 0, sizeof(LDKBlindedHop)); return res; }
+	~BlindedHop() { BlindedHop_free(self); }
+	BlindedHop& operator=(BlindedHop&& o) { BlindedHop_free(self); self = o.self; memset(&o, 0, sizeof(BlindedHop)); return *this; }
+	LDKBlindedHop* operator &() { return &self; }
+	LDKBlindedHop* operator ->() { return &self; }
+	const LDKBlindedHop* operator &() const { return &self; }
+	const LDKBlindedHop* operator ->() const { return &self; }
+};
 class CounterpartyCommitmentSecrets {
 private:
 	LDKCounterpartyCommitmentSecrets self;
@@ -808,12 +866,12 @@ public:
 	/**
 	 *  Gets estimated satoshis of fee required per 1000 Weight-Units.
 	 * 
-	 *  Must return a value no smaller than 253 (ie 1 satoshi-per-byte rounded up to ensure later
-	 *  round-downs don't put us below 1 satoshi-per-byte).
+	 *  LDK will wrap this method and ensure that the value returned is no smaller than 253
+	 *  (ie 1 satoshi-per-byte rounded up to ensure later round-downs don't put us below 1 satoshi-per-byte).
 	 * 
-	 *  This method can be implemented with the following unit conversions:
-	 *   * max(satoshis-per-byte * 250, 253)
-	 *   * max(satoshis-per-kbyte / 4, 253)
+	 *  The following unit conversions can be used to convert to sats/KW:
+	 *   * satoshis-per-byte * 250
+	 *   * satoshis-per-kbyte / 4
 	 */
 	inline uint32_t get_est_sat_per_1000_weight(enum LDKConfirmationTarget confirmation_target);
 };
@@ -847,6 +905,21 @@ public:
 	const LDKClosureReason* operator &() const { return &self; }
 	const LDKClosureReason* operator ->() const { return &self; }
 };
+class HTLCDestination {
+private:
+	LDKHTLCDestination self;
+public:
+	HTLCDestination(const HTLCDestination&) = delete;
+	HTLCDestination(HTLCDestination&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCDestination)); }
+	HTLCDestination(LDKHTLCDestination&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCDestination)); }
+	operator LDKHTLCDestination() && { LDKHTLCDestination res = self; memset(&self, 0, sizeof(LDKHTLCDestination)); return res; }
+	~HTLCDestination() { HTLCDestination_free(self); }
+	HTLCDestination& operator=(HTLCDestination&& o) { HTLCDestination_free(self); self = o.self; memset(&o, 0, sizeof(HTLCDestination)); return *this; }
+	LDKHTLCDestination* operator &() { return &self; }
+	LDKHTLCDestination* operator ->() { return &self; }
+	const LDKHTLCDestination* operator &() const { return &self; }
+	const LDKHTLCDestination* operator ->() const { return &self; }
+};
 class Event {
 private:
 	LDKEvent self;
@@ -897,6 +970,27 @@ public:
 	 */
 	inline LDK::CVec_MessageSendEventZ get_and_clear_pending_msg_events();
 };
+class OnionMessageProvider {
+private:
+	LDKOnionMessageProvider self;
+public:
+	OnionMessageProvider(const OnionMessageProvider&) = delete;
+	OnionMessageProvider(OnionMessageProvider&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessageProvider)); }
+	OnionMessageProvider(LDKOnionMessageProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessageProvider)); }
+	operator LDKOnionMessageProvider() && { LDKOnionMessageProvider res = self; memset(&self, 0, sizeof(LDKOnionMessageProvider)); return res; }
+	~OnionMessageProvider() { OnionMessageProvider_free(self); }
+	OnionMessageProvider& operator=(OnionMessageProvider&& o) { OnionMessageProvider_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessageProvider)); return *this; }
+	LDKOnionMessageProvider* operator &() { return &self; }
+	LDKOnionMessageProvider* operator ->() { return &self; }
+	const LDKOnionMessageProvider* operator &() const { return &self; }
+	const LDKOnionMessageProvider* operator ->() const { return &self; }
+	/**
+	 *  Gets the next pending onion message for the peer with the given node id.
+	 * 
+	 *  Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
+	 */
+	inline LDK::OnionMessage next_onion_message_for_peer(struct LDKPublicKey peer_node_id);
+};
 class EventsProvider {
 private:
 	LDKEventsProvider self;
@@ -914,9 +1008,7 @@ public:
 	/**
 	 *  Processes any events generated since the last call using the given event handler.
 	 * 
-	 *  Subsequent calls must only process new events. However, handlers must be capable of handling
-	 *  duplicate events across process restarts. This may occur if the provider was recovered from
-	 *  an old state (i.e., it hadn't been successfully persisted after processing pending events).
+	 *  See the trait-level documentation for requirements.
 	 */
 	inline void process_pending_events(struct LDKEventHandler handler);
 };
@@ -1047,7 +1139,7 @@ public:
 	 *  in the event of a chain reorganization, it must not be called with a `header` that is no
 	 *  longer in the chain as of the last call to [`best_block_updated`].
 	 * 
-	 *  [chain order]: Confirm#Order
+	 *  [chain order]: Confirm#order
 	 *  [`best_block_updated`]: Self::best_block_updated
 	 */
 	inline void transactions_confirmed(const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height);
@@ -1055,8 +1147,8 @@ public:
 	 *  Processes a transaction that is no longer confirmed as result of a chain reorganization.
 	 * 
 	 *  Should be called for any transaction returned by [`get_relevant_txids`] if it has been
-	 *  reorganized out of the best chain. Once called, the given transaction should not be returned
-	 *  by [`get_relevant_txids`] unless it has been reconfirmed via [`transactions_confirmed`].
+	 *  reorganized out of the best chain. Once called, the given transaction will not be returned
+	 *  by [`get_relevant_txids`], unless it has been reconfirmed via [`transactions_confirmed`].
 	 * 
 	 *  [`get_relevant_txids`]: Self::get_relevant_txids
 	 *  [`transactions_confirmed`]: Self::transactions_confirmed
@@ -1072,9 +1164,9 @@ public:
 	/**
 	 *  Returns transactions that should be monitored for reorganization out of the chain.
 	 * 
-	 *  Should include any transactions passed to [`transactions_confirmed`] that have insufficient
-	 *  confirmations to be safe from a chain reorganization. Should not include any transactions
-	 *  passed to [`transaction_unconfirmed`] unless later reconfirmed.
+	 *  Will include any transactions passed to [`transactions_confirmed`] that have insufficient
+	 *  confirmations to be safe from a chain reorganization. Will not include any transactions
+	 *  passed to [`transaction_unconfirmed`], unless later reconfirmed.
 	 * 
 	 *  May be called to determine the subset of transactions that must still be monitored for
 	 *  reorganization. Will be idempotent between calls but may change as a result of calls to the
@@ -1086,19 +1178,19 @@ public:
 	 */
 	inline LDK::CVec_TxidZ get_relevant_txids();
 };
-class ChannelMonitorUpdateErr {
+class ChannelMonitorUpdateStatus {
 private:
-	LDKChannelMonitorUpdateErr self;
+	LDKChannelMonitorUpdateStatus self;
 public:
-	ChannelMonitorUpdateErr(const ChannelMonitorUpdateErr&) = delete;
-	ChannelMonitorUpdateErr(ChannelMonitorUpdateErr&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitorUpdateErr)); }
-	ChannelMonitorUpdateErr(LDKChannelMonitorUpdateErr&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitorUpdateErr)); }
-	operator LDKChannelMonitorUpdateErr() && { LDKChannelMonitorUpdateErr res = self; memset(&self, 0, sizeof(LDKChannelMonitorUpdateErr)); return res; }
-	ChannelMonitorUpdateErr& operator=(ChannelMonitorUpdateErr&& o) { self = o.self; memset(&o, 0, sizeof(ChannelMonitorUpdateErr)); return *this; }
-	LDKChannelMonitorUpdateErr* operator &() { return &self; }
-	LDKChannelMonitorUpdateErr* operator ->() { return &self; }
-	const LDKChannelMonitorUpdateErr* operator &() const { return &self; }
-	const LDKChannelMonitorUpdateErr* operator ->() const { return &self; }
+	ChannelMonitorUpdateStatus(const ChannelMonitorUpdateStatus&) = delete;
+	ChannelMonitorUpdateStatus(ChannelMonitorUpdateStatus&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitorUpdateStatus)); }
+	ChannelMonitorUpdateStatus(LDKChannelMonitorUpdateStatus&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitorUpdateStatus)); }
+	operator LDKChannelMonitorUpdateStatus() && { LDKChannelMonitorUpdateStatus res = self; memset(&self, 0, sizeof(LDKChannelMonitorUpdateStatus)); return res; }
+	ChannelMonitorUpdateStatus& operator=(ChannelMonitorUpdateStatus&& o) { self = o.self; memset(&o, 0, sizeof(ChannelMonitorUpdateStatus)); return *this; }
+	LDKChannelMonitorUpdateStatus* operator &() { return &self; }
+	LDKChannelMonitorUpdateStatus* operator ->() { return &self; }
+	const LDKChannelMonitorUpdateStatus* operator &() const { return &self; }
+	const LDKChannelMonitorUpdateStatus* operator ->() const { return &self; }
 };
 class Watch {
 private:
@@ -1121,23 +1213,23 @@ public:
 	 *  with any spends of outputs returned by [`get_outputs_to_watch`]. In practice, this means
 	 *  calling [`block_connected`] and [`block_disconnected`] on the monitor.
 	 * 
-	 *  Note: this interface MUST error with `ChannelMonitorUpdateErr::PermanentFailure` if
+	 *  Note: this interface MUST error with [`ChannelMonitorUpdateStatus::PermanentFailure`] if
 	 *  the given `funding_txo` has previously been registered via `watch_channel`.
 	 * 
 	 *  [`get_outputs_to_watch`]: channelmonitor::ChannelMonitor::get_outputs_to_watch
 	 *  [`block_connected`]: channelmonitor::ChannelMonitor::block_connected
 	 *  [`block_disconnected`]: channelmonitor::ChannelMonitor::block_disconnected
 	 */
-	inline LDK::CResult_NoneChannelMonitorUpdateErrZ watch_channel(struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor);
+	inline LDK::ChannelMonitorUpdateStatus watch_channel(struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor);
 	/**
 	 *  Updates a channel identified by `funding_txo` by applying `update` to its monitor.
 	 * 
 	 *  Implementations must call [`update_monitor`] with the given update. See
-	 *  [`ChannelMonitorUpdateErr`] for invariants around returning an error.
+	 *  [`ChannelMonitorUpdateStatus`] for invariants around returning an error.
 	 * 
 	 *  [`update_monitor`]: channelmonitor::ChannelMonitor::update_monitor
 	 */
-	inline LDK::CResult_NoneChannelMonitorUpdateErrZ update_channel(struct LDKOutPoint funding_txo, struct LDKChannelMonitorUpdate update);
+	inline LDK::ChannelMonitorUpdateStatus update_channel(struct LDKOutPoint funding_txo, struct LDKChannelMonitorUpdate update);
 	/**
 	 *  Returns any monitor events since the last call. Subsequent calls must only return new
 	 *  events.
@@ -1147,9 +1239,9 @@ public:
 	 *  to disk.
 	 * 
 	 *  For details on asynchronous [`ChannelMonitor`] updating and returning
-	 *  [`MonitorEvent::UpdateCompleted`] here, see [`ChannelMonitorUpdateErr::TemporaryFailure`].
+	 *  [`MonitorEvent::Completed`] here, see [`ChannelMonitorUpdateStatus::InProgress`].
 	 */
-	inline LDK::CVec_C2Tuple_OutPointCVec_MonitorEventZZZ release_pending_monitor_events();
+	inline LDK::CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ release_pending_monitor_events();
 };
 class Filter {
 private:
@@ -1173,15 +1265,12 @@ public:
 	/**
 	 *  Registers interest in spends of a transaction output.
 	 * 
-	 *  Optionally, when `output.block_hash` is set, should return any transaction spending the
-	 *  output that is found in the corresponding block along with its index.
-	 * 
-	 *  This return value is useful for Electrum clients in order to supply in-block descendant
-	 *  transactions which otherwise were not included. This is not necessary for other clients if
-	 *  such descendant transactions were already included (e.g., when a BIP 157 client provides the
-	 *  full block).
+	 *  Note that this method might be called during processing of a new block. You therefore need
+	 *  to ensure that also dependent output spents within an already connected block are correctly
+	 *  handled, e.g., by re-scanning the block in question whenever new outputs have been
+	 *  registered mid-processing.
 	 */
-	inline LDK::COption_C2Tuple_usizeTransactionZZ register_output(struct LDKWatchedOutput output);
+	inline void register_output(struct LDKWatchedOutput output);
 };
 class WatchedOutput {
 private:
@@ -1231,6 +1320,14 @@ public:
 	 *  Handles updating channel penalties after successfully routing along a path.
 	 */
 	inline void payment_path_successful(struct LDKCVec_RouteHopZ path);
+	/**
+	 *  Handles updating channel penalties after a probe over the given path failed.
+	 */
+	inline void probe_failed(struct LDKCVec_RouteHopZ path, uint64_t short_channel_id);
+	/**
+	 *  Handles updating channel penalties after a probe over the given path succeeded.
+	 */
+	inline void probe_successful(struct LDKCVec_RouteHopZ path);
 };
 class LockableScore {
 private:
@@ -1251,6 +1348,21 @@ public:
 	 */
 	inline LDK::Score lock();
 };
+class WriteableScore {
+private:
+	LDKWriteableScore self;
+public:
+	WriteableScore(const WriteableScore&) = delete;
+	WriteableScore(WriteableScore&& o) : self(o.self) { memset(&o, 0, sizeof(WriteableScore)); }
+	WriteableScore(LDKWriteableScore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWriteableScore)); }
+	operator LDKWriteableScore() && { LDKWriteableScore res = self; memset(&self, 0, sizeof(LDKWriteableScore)); return res; }
+	~WriteableScore() { WriteableScore_free(self); }
+	WriteableScore& operator=(WriteableScore&& o) { WriteableScore_free(self); self = o.self; memset(&o, 0, sizeof(WriteableScore)); return *this; }
+	LDKWriteableScore* operator &() { return &self; }
+	LDKWriteableScore* operator ->() { return &self; }
+	const LDKWriteableScore* operator &() const { return &self; }
+	const LDKWriteableScore* operator ->() const { return &self; }
+};
 class MultiThreadedLockableScore {
 private:
 	LDKMultiThreadedLockableScore self;
@@ -1266,6 +1378,21 @@ public:
 	const LDKMultiThreadedLockableScore* operator &() const { return &self; }
 	const LDKMultiThreadedLockableScore* operator ->() const { return &self; }
 };
+class MultiThreadedScoreLock {
+private:
+	LDKMultiThreadedScoreLock self;
+public:
+	MultiThreadedScoreLock(const MultiThreadedScoreLock&) = delete;
+	MultiThreadedScoreLock(MultiThreadedScoreLock&& o) : self(o.self) { memset(&o, 0, sizeof(MultiThreadedScoreLock)); }
+	MultiThreadedScoreLock(LDKMultiThreadedScoreLock&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMultiThreadedScoreLock)); }
+	operator LDKMultiThreadedScoreLock() && { LDKMultiThreadedScoreLock res = self; memset(&self, 0, sizeof(LDKMultiThreadedScoreLock)); return res; }
+	~MultiThreadedScoreLock() { MultiThreadedScoreLock_free(self); }
+	MultiThreadedScoreLock& operator=(MultiThreadedScoreLock&& o) { MultiThreadedScoreLock_free(self); self = o.self; memset(&o, 0, sizeof(MultiThreadedScoreLock)); return *this; }
+	LDKMultiThreadedScoreLock* operator &() { return &self; }
+	LDKMultiThreadedScoreLock* operator ->() { return &self; }
+	const LDKMultiThreadedScoreLock* operator &() const { return &self; }
+	const LDKMultiThreadedScoreLock* operator ->() const { return &self; }
+};
 class ChannelUsage {
 private:
 	LDKChannelUsage self;
@@ -1401,6 +1528,25 @@ public:
 	const LDKChannelTypeFeatures* operator &() const { return &self; }
 	const LDKChannelTypeFeatures* operator ->() const { return &self; }
 };
+class CustomOnionMessageContents {
+private:
+	LDKCustomOnionMessageContents self;
+public:
+	CustomOnionMessageContents(const CustomOnionMessageContents&) = delete;
+	CustomOnionMessageContents(CustomOnionMessageContents&& o) : self(o.self) { memset(&o, 0, sizeof(CustomOnionMessageContents)); }
+	CustomOnionMessageContents(LDKCustomOnionMessageContents&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCustomOnionMessageContents)); }
+	operator LDKCustomOnionMessageContents() && { LDKCustomOnionMessageContents res = self; memset(&self, 0, sizeof(LDKCustomOnionMessageContents)); return res; }
+	~CustomOnionMessageContents() { CustomOnionMessageContents_free(self); }
+	CustomOnionMessageContents& operator=(CustomOnionMessageContents&& o) { CustomOnionMessageContents_free(self); self = o.self; memset(&o, 0, sizeof(CustomOnionMessageContents)); return *this; }
+	LDKCustomOnionMessageContents* operator &() { return &self; }
+	LDKCustomOnionMessageContents* operator ->() { return &self; }
+	const LDKCustomOnionMessageContents* operator &() const { return &self; }
+	const LDKCustomOnionMessageContents* operator ->() const { return &self; }
+	/**
+	 *  Returns the TLV type identifying the message contents. MUST be >= 64.
+	 */
+	inline uint64_t tlv_type();
+};
 class NodeId {
 private:
 	LDKNodeId self;
@@ -1795,6 +1941,11 @@ public:
 	 *  chosen to forgo their output as dust.
 	 */
 	inline LDK::CResult_SignatureNoneZ sign_closing_transaction(const struct LDKClosingTransaction *NONNULL_PTR closing_tx);
+	/**
+	 *  Computes the signature for a commitment transaction's anchor output used as an
+	 *  input within `anchor_tx`, which spends the commitment transaction, at index `input`.
+	 */
+	inline LDK::CResult_SignatureNoneZ sign_holder_anchor_input(struct LDKTransaction anchor_tx, uintptr_t input);
 	/**
 	 *  Signs a channel announcement message with our funding key and our node secret key (aka
 	 *  node_id or network_key), proving it comes from one of the channel participants.
@@ -1871,8 +2022,32 @@ public:
 	 * 
 	 *  This method must return the same value each time it is called with a given `Recipient`
 	 *  parameter.
+	 * 
+	 *  Errors if the `Recipient` variant is not supported by the implementation.
 	 */
 	inline LDK::CResult_SecretKeyNoneZ get_node_secret(enum LDKRecipient recipient);
+	/**
+	 *  Get node id based on the provided [`Recipient`]. This public key corresponds to the secret in
+	 *  [`get_node_secret`].
+	 * 
+	 *  This method must return the same value each time it is called with a given `Recipient`
+	 *  parameter.
+	 * 
+	 *  Errors if the `Recipient` variant is not supported by the implementation.
+	 * 
+	 *  [`get_node_secret`]: KeysInterface::get_node_secret
+	 */
+	inline LDK::CResult_PublicKeyNoneZ get_node_id(enum LDKRecipient recipient);
+	/**
+	 *  Gets the ECDH shared secret of our [`node secret`] and `other_key`, multiplying by `tweak` if
+	 *  one is provided. Note that this tweak can be applied to `other_key` instead of our node
+	 *  secret, though this is less efficient.
+	 * 
+	 *  Errors if the `Recipient` variant is not supported by the implementation.
+	 * 
+	 *  [`node secret`]: Self::get_node_secret
+	 */
+	inline LDK::CResult_SharedSecretNoneZ ecdh(enum LDKRecipient recipient, struct LDKPublicKey other_key, struct LDKCOption_ScalarZ tweak);
 	/**
 	 *  Get a script pubkey which we send funds to when claiming on-chain contestable outputs.
 	 * 
@@ -1919,6 +2094,8 @@ public:
 	 *  The hrp is ascii bytes, while the invoice data is base32.
 	 * 
 	 *  The secret key used to sign the invoice is dependent on the [`Recipient`].
+	 * 
+	 *  Errors if the `Recipient` variant is not supported by the implementation.
 	 */
 	inline LDK::CResult_RecoverableSignatureNoneZ sign_invoice(struct LDKu8slice hrp_bytes, struct LDKCVec_u5Z invoice_data, enum LDKRecipient receipient);
 	/**
@@ -2204,6 +2381,21 @@ public:
 	const LDKBigSize* operator &() const { return &self; }
 	const LDKBigSize* operator ->() const { return &self; }
 };
+class Hostname {
+private:
+	LDKHostname self;
+public:
+	Hostname(const Hostname&) = delete;
+	Hostname(Hostname&& o) : self(o.self) { memset(&o, 0, sizeof(Hostname)); }
+	Hostname(LDKHostname&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHostname)); }
+	operator LDKHostname() && { LDKHostname res = self; memset(&self, 0, sizeof(LDKHostname)); return res; }
+	~Hostname() { Hostname_free(self); }
+	Hostname& operator=(Hostname&& o) { Hostname_free(self); self = o.self; memset(&o, 0, sizeof(Hostname)); return *this; }
+	LDKHostname* operator &() { return &self; }
+	LDKHostname* operator ->() { return &self; }
+	const LDKHostname* operator &() const { return &self; }
+	const LDKHostname* operator ->() const { return &self; }
+};
 class OutPoint {
 private:
 	LDKOutPoint self;
@@ -2339,7 +2531,23 @@ public:
 	 * 
 	 *  Note that first_hops (or a relevant inner pointer) may be NULL or all-0s to represent None
 	 */
-	inline LDK::CResult_RouteLightningErrorZ find_route(struct LDKPublicKey payer, const struct LDKRouteParameters *NONNULL_PTR route_params, const uint8_t (*payment_hash)[32], struct LDKCVec_ChannelDetailsZ *first_hops, const struct LDKScore *NONNULL_PTR scorer);
+	inline LDK::CResult_RouteLightningErrorZ find_route(struct LDKPublicKey payer, const struct LDKRouteParameters *NONNULL_PTR route_params, const uint8_t (*payment_hash)[32], struct LDKCVec_ChannelDetailsZ *first_hops, struct LDKInFlightHtlcs inflight_htlcs);
+	/**
+	 *  Lets the router know that payment through a specific path has failed.
+	 */
+	inline void notify_payment_path_failed(struct LDKCVec_RouteHopZ path, uint64_t short_channel_id);
+	/**
+	 *  Lets the router know that payment through a specific path was successful.
+	 */
+	inline void notify_payment_path_successful(struct LDKCVec_RouteHopZ path);
+	/**
+	 *  Lets the router know that a payment probe was successful.
+	 */
+	inline void notify_payment_probe_successful(struct LDKCVec_RouteHopZ path);
+	/**
+	 *  Lets the router know that a payment probe failed.
+	 */
+	inline void notify_payment_probe_failed(struct LDKCVec_RouteHopZ path, uint64_t short_channel_id);
 };
 class Retry {
 private:
@@ -2371,6 +2579,21 @@ public:
 	const LDKPaymentError* operator &() const { return &self; }
 	const LDKPaymentError* operator ->() const { return &self; }
 };
+class InFlightHtlcs {
+private:
+	LDKInFlightHtlcs self;
+public:
+	InFlightHtlcs(const InFlightHtlcs&) = delete;
+	InFlightHtlcs(InFlightHtlcs&& o) : self(o.self) { memset(&o, 0, sizeof(InFlightHtlcs)); }
+	InFlightHtlcs(LDKInFlightHtlcs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInFlightHtlcs)); }
+	operator LDKInFlightHtlcs() && { LDKInFlightHtlcs res = self; memset(&self, 0, sizeof(LDKInFlightHtlcs)); return res; }
+	~InFlightHtlcs() { InFlightHtlcs_free(self); }
+	InFlightHtlcs& operator=(InFlightHtlcs&& o) { InFlightHtlcs_free(self); self = o.self; memset(&o, 0, sizeof(InFlightHtlcs)); return *this; }
+	LDKInFlightHtlcs* operator &() { return &self; }
+	LDKInFlightHtlcs* operator ->() { return &self; }
+	const LDKInFlightHtlcs* operator &() const { return &self; }
+	const LDKInFlightHtlcs* operator ->() const { return &self; }
+};
 class ParseError {
 private:
 	LDKParseError self;
@@ -2908,6 +3131,75 @@ public:
 	const LDKPeerManager* operator &() const { return &self; }
 	const LDKPeerManager* operator ->() const { return &self; }
 };
+class OnionMessenger {
+private:
+	LDKOnionMessenger self;
+public:
+	OnionMessenger(const OnionMessenger&) = delete;
+	OnionMessenger(OnionMessenger&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessenger)); }
+	OnionMessenger(LDKOnionMessenger&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessenger)); }
+	operator LDKOnionMessenger() && { LDKOnionMessenger res = self; memset(&self, 0, sizeof(LDKOnionMessenger)); return res; }
+	~OnionMessenger() { OnionMessenger_free(self); }
+	OnionMessenger& operator=(OnionMessenger&& o) { OnionMessenger_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessenger)); return *this; }
+	LDKOnionMessenger* operator &() { return &self; }
+	LDKOnionMessenger* operator ->() { return &self; }
+	const LDKOnionMessenger* operator &() const { return &self; }
+	const LDKOnionMessenger* operator ->() const { return &self; }
+};
+class Destination {
+private:
+	LDKDestination self;
+public:
+	Destination(const Destination&) = delete;
+	Destination(Destination&& o) : self(o.self) { memset(&o, 0, sizeof(Destination)); }
+	Destination(LDKDestination&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDestination)); }
+	operator LDKDestination() && { LDKDestination res = self; memset(&self, 0, sizeof(LDKDestination)); return res; }
+	~Destination() { Destination_free(self); }
+	Destination& operator=(Destination&& o) { Destination_free(self); self = o.self; memset(&o, 0, sizeof(Destination)); return *this; }
+	LDKDestination* operator &() { return &self; }
+	LDKDestination* operator ->() { return &self; }
+	const LDKDestination* operator &() const { return &self; }
+	const LDKDestination* operator ->() const { return &self; }
+};
+class SendError {
+private:
+	LDKSendError self;
+public:
+	SendError(const SendError&) = delete;
+	SendError(SendError&& o) : self(o.self) { memset(&o, 0, sizeof(SendError)); }
+	SendError(LDKSendError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSendError)); }
+	operator LDKSendError() && { LDKSendError res = self; memset(&self, 0, sizeof(LDKSendError)); return res; }
+	~SendError() { SendError_free(self); }
+	SendError& operator=(SendError&& o) { SendError_free(self); self = o.self; memset(&o, 0, sizeof(SendError)); return *this; }
+	LDKSendError* operator &() { return &self; }
+	LDKSendError* operator ->() { return &self; }
+	const LDKSendError* operator &() const { return &self; }
+	const LDKSendError* operator ->() const { return &self; }
+};
+class CustomOnionMessageHandler {
+private:
+	LDKCustomOnionMessageHandler self;
+public:
+	CustomOnionMessageHandler(const CustomOnionMessageHandler&) = delete;
+	CustomOnionMessageHandler(CustomOnionMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(CustomOnionMessageHandler)); }
+	CustomOnionMessageHandler(LDKCustomOnionMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCustomOnionMessageHandler)); }
+	operator LDKCustomOnionMessageHandler() && { LDKCustomOnionMessageHandler res = self; memset(&self, 0, sizeof(LDKCustomOnionMessageHandler)); return res; }
+	~CustomOnionMessageHandler() { CustomOnionMessageHandler_free(self); }
+	CustomOnionMessageHandler& operator=(CustomOnionMessageHandler&& o) { CustomOnionMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(CustomOnionMessageHandler)); return *this; }
+	LDKCustomOnionMessageHandler* operator &() { return &self; }
+	LDKCustomOnionMessageHandler* operator ->() { return &self; }
+	const LDKCustomOnionMessageHandler* operator &() const { return &self; }
+	const LDKCustomOnionMessageHandler* operator ->() const { return &self; }
+	/**
+	 *  Called with the custom message that was received.
+	 */
+	inline void handle_custom_message(struct LDKCustomOnionMessageContents msg);
+	/**
+	 *  Read a custom message of type `message_type` from `buffer`, returning `Ok(None)` if the
+	 *  message type is unknown.
+	 */
+	inline LDK::CResult_COption_CustomOnionMessageContentsZDecodeErrorZ read_custom_message(uint64_t message_type, struct LDKu8slice buffer);
+};
 class RapidGossipSync {
 private:
 	LDKRapidGossipSync self;
@@ -2946,9 +3238,9 @@ public:
 	 */
 	inline LDK::CResult_NoneErrorZ persist_graph(const struct LDKNetworkGraph *NONNULL_PTR network_graph);
 	/**
-	 *  Persist the given [`MultiThreadedLockableScore`] to disk, returning an error if persistence failed.
+	 *  Persist the given [`WriteableScore`] to disk, returning an error if persistence failed.
 	 */
-	inline LDK::CResult_NoneErrorZ persist_scorer(const struct LDKMultiThreadedLockableScore *NONNULL_PTR scorer);
+	inline LDK::CResult_NoneErrorZ persist_scorer(const struct LDKWriteableScore *NONNULL_PTR scorer);
 };
 class DecodeError {
 private:
@@ -3175,6 +3467,21 @@ public:
 	const LDKUpdateAddHTLC* operator &() const { return &self; }
 	const LDKUpdateAddHTLC* operator ->() const { return &self; }
 };
+class OnionMessage {
+private:
+	LDKOnionMessage self;
+public:
+	OnionMessage(const OnionMessage&) = delete;
+	OnionMessage(OnionMessage&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessage)); }
+	OnionMessage(LDKOnionMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessage)); }
+	operator LDKOnionMessage() && { LDKOnionMessage res = self; memset(&self, 0, sizeof(LDKOnionMessage)); return res; }
+	~OnionMessage() { OnionMessage_free(self); }
+	OnionMessage& operator=(OnionMessage&& o) { OnionMessage_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessage)); return *this; }
+	LDKOnionMessage* operator &() { return &self; }
+	LDKOnionMessage* operator ->() { return &self; }
+	const LDKOnionMessage* operator &() const { return &self; }
+	const LDKOnionMessage* operator ->() const { return &self; }
+};
 class UpdateFulfillHTLC {
 private:
 	LDKUpdateFulfillHTLC self;
@@ -3614,12 +3921,19 @@ public:
 	 *  is believed to be possible in the future (eg they're sending us messages we don't
 	 *  understand or indicate they require unknown feature bits), no_connection_possible is set
 	 *  and any outstanding channels should be failed.
+	 * 
+	 *  Note that in some rare cases this may be called without a corresponding
+	 *  [`Self::peer_connected`].
 	 */
 	inline void peer_disconnected(struct LDKPublicKey their_node_id, bool no_connection_possible);
 	/**
 	 *  Handle a peer reconnecting, possibly generating channel_reestablish message(s).
+	 * 
+	 *  May return an `Err(())` if the features the peer supports are not sufficient to communicate
+	 *  with us. Implementors should be somewhat conservative about doing so, however, as other
+	 *  message handlers may still wish to communicate with this peer.
 	 */
-	inline void peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg);
+	inline LDK::CResult_NoneNoneZ peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg);
 	/**
 	 *  Handle an incoming channel_reestablish message from the given peer.
 	 */
@@ -3632,6 +3946,20 @@ public:
 	 *  Handle an incoming error message from the given peer.
 	 */
 	inline void handle_error(struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg);
+	/**
+	 *  Gets the node feature flags which this handler itself supports. All available handlers are
+	 *  queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
+	 *  which are broadcasted in our [`NodeAnnouncement`] message.
+	 */
+	inline LDK::NodeFeatures provided_node_features();
+	/**
+	 *  Gets the init feature flags which should be sent to the given peer. All available handlers
+	 *  are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
+	 *  which are sent in our [`Init`] message.
+	 * 
+	 *  Note that this method is called before [`Self::peer_connected`].
+	 */
+	inline LDK::InitFeatures provided_init_features(struct LDKPublicKey their_node_id);
 };
 class RoutingMessageHandler {
 private:
@@ -3663,26 +3991,31 @@ public:
 	 */
 	inline LDK::CResult_boolLightningErrorZ handle_channel_update(const struct LDKChannelUpdate *NONNULL_PTR msg);
 	/**
-	 *  Gets a subset of the channel announcements and updates required to dump our routing table
-	 *  to a remote node, starting at the short_channel_id indicated by starting_point and
-	 *  including the batch_amount entries immediately higher in numerical value than starting_point.
+	 *  Gets channel announcements and updates required to dump our routing table to a remote node,
+	 *  starting at the short_channel_id indicated by starting_point and including announcements
+	 *  for a single channel.
 	 */
-	inline LDK::CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ get_next_channel_announcements(uint64_t starting_point, uint8_t batch_amount);
+	inline LDK::COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ get_next_channel_announcement(uint64_t starting_point);
 	/**
-	 *  Gets a subset of the node announcements required to dump our routing table to a remote node,
-	 *  starting at the node *after* the provided publickey and including batch_amount entries
-	 *  immediately higher (as defined by <PublicKey as Ord>::cmp) than starting_point.
+	 *  Gets a node announcement required to dump our routing table to a remote node, starting at
+	 *  the node *after* the provided pubkey and including up to one announcement immediately
+	 *  higher (as defined by <PublicKey as Ord>::cmp) than starting_point.
 	 *  If None is provided for starting_point, we start at the first node.
 	 * 
 	 *  Note that starting_point (or a relevant inner pointer) may be NULL or all-0s to represent None
+	 *  Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
 	 */
-	inline LDK::CVec_NodeAnnouncementZ get_next_node_announcements(struct LDKPublicKey starting_point, uint8_t batch_amount);
+	inline LDK::NodeAnnouncement get_next_node_announcement(struct LDKPublicKey starting_point);
 	/**
 	 *  Called when a connection is established with a peer. This can be used to
 	 *  perform routing table synchronization using a strategy defined by the
 	 *  implementor.
+	 * 
+	 *  May return an `Err(())` if the features the peer supports are not sufficient to communicate
+	 *  with us. Implementors should be somewhat conservative about doing so, however, as other
+	 *  message handlers may still wish to communicate with this peer.
 	 */
-	inline void peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init);
+	inline LDK::CResult_NoneNoneZ peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init);
 	/**
 	 *  Handles the reply of a query we initiated to learn about channels
 	 *  for a given range of blocks. We can expect to receive one or more
@@ -3706,6 +4039,70 @@ public:
 	 *  list of short_channel_ids.
 	 */
 	inline LDK::CResult_NoneLightningErrorZ handle_query_short_channel_ids(struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg);
+	/**
+	 *  Gets the node feature flags which this handler itself supports. All available handlers are
+	 *  queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
+	 *  which are broadcasted in our [`NodeAnnouncement`] message.
+	 */
+	inline LDK::NodeFeatures provided_node_features();
+	/**
+	 *  Gets the init feature flags which should be sent to the given peer. All available handlers
+	 *  are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
+	 *  which are sent in our [`Init`] message.
+	 * 
+	 *  Note that this method is called before [`Self::peer_connected`].
+	 */
+	inline LDK::InitFeatures provided_init_features(struct LDKPublicKey their_node_id);
+};
+class OnionMessageHandler {
+private:
+	LDKOnionMessageHandler self;
+public:
+	OnionMessageHandler(const OnionMessageHandler&) = delete;
+	OnionMessageHandler(OnionMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessageHandler)); }
+	OnionMessageHandler(LDKOnionMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessageHandler)); }
+	operator LDKOnionMessageHandler() && { LDKOnionMessageHandler res = self; memset(&self, 0, sizeof(LDKOnionMessageHandler)); return res; }
+	~OnionMessageHandler() { OnionMessageHandler_free(self); }
+	OnionMessageHandler& operator=(OnionMessageHandler&& o) { OnionMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessageHandler)); return *this; }
+	LDKOnionMessageHandler* operator &() { return &self; }
+	LDKOnionMessageHandler* operator ->() { return &self; }
+	const LDKOnionMessageHandler* operator &() const { return &self; }
+	const LDKOnionMessageHandler* operator ->() const { return &self; }
+	/**
+	 *  Handle an incoming onion_message message from the given peer.
+	 */
+	inline void handle_onion_message(struct LDKPublicKey peer_node_id, const struct LDKOnionMessage *NONNULL_PTR msg);
+	/**
+	 *  Called when a connection is established with a peer. Can be used to track which peers
+	 *  advertise onion message support and are online.
+	 * 
+	 *  May return an `Err(())` if the features the peer supports are not sufficient to communicate
+	 *  with us. Implementors should be somewhat conservative about doing so, however, as other
+	 *  message handlers may still wish to communicate with this peer.
+	 */
+	inline LDK::CResult_NoneNoneZ peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init);
+	/**
+	 *  Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
+	 *  drop and refuse to forward onion messages to this peer.
+	 * 
+	 *  Note that in some rare cases this may be called without a corresponding
+	 *  [`Self::peer_connected`].
+	 */
+	inline void peer_disconnected(struct LDKPublicKey their_node_id, bool no_connection_possible);
+	/**
+	 *  Gets the node feature flags which this handler itself supports. All available handlers are
+	 *  queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
+	 *  which are broadcasted in our [`NodeAnnouncement`] message.
+	 */
+	inline LDK::NodeFeatures provided_node_features();
+	/**
+	 *  Gets the init feature flags which should be sent to the given peer. All available handlers
+	 *  are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
+	 *  which are sent in our [`Init`] message.
+	 * 
+	 *  Note that this method is called before [`Self::peer_connected`].
+	 */
+	inline LDK::InitFeatures provided_init_features(struct LDKPublicKey their_node_id);
 };
 class GraphSyncError {
 private:
@@ -3785,6 +4182,40 @@ public:
 	 */
 	inline void log(const struct LDKRecord *NONNULL_PTR record);
 };
+class FutureCallback {
+private:
+	LDKFutureCallback self;
+public:
+	FutureCallback(const FutureCallback&) = delete;
+	FutureCallback(FutureCallback&& o) : self(o.self) { memset(&o, 0, sizeof(FutureCallback)); }
+	FutureCallback(LDKFutureCallback&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFutureCallback)); }
+	operator LDKFutureCallback() && { LDKFutureCallback res = self; memset(&self, 0, sizeof(LDKFutureCallback)); return res; }
+	~FutureCallback() { FutureCallback_free(self); }
+	FutureCallback& operator=(FutureCallback&& o) { FutureCallback_free(self); self = o.self; memset(&o, 0, sizeof(FutureCallback)); return *this; }
+	LDKFutureCallback* operator &() { return &self; }
+	LDKFutureCallback* operator ->() { return &self; }
+	const LDKFutureCallback* operator &() const { return &self; }
+	const LDKFutureCallback* operator ->() const { return &self; }
+	/**
+	 *  The method which is called.
+	 */
+	inline void call();
+};
+class Future {
+private:
+	LDKFuture self;
+public:
+	Future(const Future&) = delete;
+	Future(Future&& o) : self(o.self) { memset(&o, 0, sizeof(Future)); }
+	Future(LDKFuture&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFuture)); }
+	operator LDKFuture() && { LDKFuture res = self; memset(&self, 0, sizeof(LDKFuture)); return res; }
+	~Future() { Future_free(self); }
+	Future& operator=(Future&& o) { Future_free(self); self = o.self; memset(&o, 0, sizeof(Future)); return *this; }
+	LDKFuture* operator &() { return &self; }
+	LDKFuture* operator ->() { return &self; }
+	const LDKFuture* operator &() const { return &self; }
+	const LDKFuture* operator ->() const { return &self; }
+};
 class MonitorUpdateId {
 private:
 	LDKMonitorUpdateId self;
@@ -3823,15 +4254,15 @@ public:
 	 *  and the stored channel data). Note that you **must** persist every new monitor to disk.
 	 * 
 	 *  The `update_id` is used to identify this call to [`ChainMonitor::channel_monitor_updated`],
-	 *  if you return [`ChannelMonitorUpdateErr::TemporaryFailure`].
+	 *  if you return [`ChannelMonitorUpdateStatus::InProgress`].
 	 * 
 	 *  See [`Writeable::write`] on [`ChannelMonitor`] for writing out a `ChannelMonitor`
-	 *  and [`ChannelMonitorUpdateErr`] for requirements when returning errors.
+	 *  and [`ChannelMonitorUpdateStatus`] for requirements when returning errors.
 	 * 
 	 *  [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
 	 *  [`Writeable::write`]: crate::util::ser::Writeable::write
 	 */
-	inline LDK::CResult_NoneChannelMonitorUpdateErrZ persist_new_channel(struct LDKOutPoint channel_id, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id);
+	inline LDK::ChannelMonitorUpdateStatus persist_new_channel(struct LDKOutPoint channel_id, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id);
 	/**
 	 *  Update one channel's data. The provided [`ChannelMonitor`] has already applied the given
 	 *  update.
@@ -3859,17 +4290,17 @@ public:
 	 *  whereas updates are small and `O(1)`.
 	 * 
 	 *  The `update_id` is used to identify this call to [`ChainMonitor::channel_monitor_updated`],
-	 *  if you return [`ChannelMonitorUpdateErr::TemporaryFailure`].
+	 *  if you return [`ChannelMonitorUpdateStatus::InProgress`].
 	 * 
 	 *  See [`Writeable::write`] on [`ChannelMonitor`] for writing out a `ChannelMonitor`,
 	 *  [`Writeable::write`] on [`ChannelMonitorUpdate`] for writing out an update, and
-	 *  [`ChannelMonitorUpdateErr`] for requirements when returning errors.
+	 *  [`ChannelMonitorUpdateStatus`] for requirements when returning errors.
 	 * 
 	 *  [`Writeable::write`]: crate::util::ser::Writeable::write
 	 * 
 	 *  Note that update (or a relevant inner pointer) may be NULL or all-0s to represent None
 	 */
-	inline LDK::CResult_NoneChannelMonitorUpdateErrZ update_persisted_channel(struct LDKOutPoint channel_id, const struct LDKChannelMonitorUpdate *NONNULL_PTR update, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id);
+	inline LDK::ChannelMonitorUpdateStatus update_persisted_channel(struct LDKOutPoint channel_id, const struct LDKChannelMonitorUpdate *NONNULL_PTR update, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id);
 };
 class LockedChannelMonitor {
 private:
@@ -4051,6 +4482,36 @@ public:
 	const LDKCResult_ChannelInfoDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_ChannelInfoDecodeErrorZ* operator ->() const { return &self; }
 };
+class COption_WriteableScoreZ {
+private:
+	LDKCOption_WriteableScoreZ self;
+public:
+	COption_WriteableScoreZ(const COption_WriteableScoreZ&) = delete;
+	COption_WriteableScoreZ(COption_WriteableScoreZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_WriteableScoreZ)); }
+	COption_WriteableScoreZ(LDKCOption_WriteableScoreZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_WriteableScoreZ)); }
+	operator LDKCOption_WriteableScoreZ() && { LDKCOption_WriteableScoreZ res = self; memset(&self, 0, sizeof(LDKCOption_WriteableScoreZ)); return res; }
+	~COption_WriteableScoreZ() { COption_WriteableScoreZ_free(self); }
+	COption_WriteableScoreZ& operator=(COption_WriteableScoreZ&& o) { COption_WriteableScoreZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_WriteableScoreZ)); return *this; }
+	LDKCOption_WriteableScoreZ* operator &() { return &self; }
+	LDKCOption_WriteableScoreZ* operator ->() { return &self; }
+	const LDKCOption_WriteableScoreZ* operator &() const { return &self; }
+	const LDKCOption_WriteableScoreZ* operator ->() const { return &self; }
+};
+class CResult_NoneSendErrorZ {
+private:
+	LDKCResult_NoneSendErrorZ self;
+public:
+	CResult_NoneSendErrorZ(const CResult_NoneSendErrorZ&) = delete;
+	CResult_NoneSendErrorZ(CResult_NoneSendErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneSendErrorZ)); }
+	CResult_NoneSendErrorZ(LDKCResult_NoneSendErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneSendErrorZ)); }
+	operator LDKCResult_NoneSendErrorZ() && { LDKCResult_NoneSendErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneSendErrorZ)); return res; }
+	~CResult_NoneSendErrorZ() { CResult_NoneSendErrorZ_free(self); }
+	CResult_NoneSendErrorZ& operator=(CResult_NoneSendErrorZ&& o) { CResult_NoneSendErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneSendErrorZ)); return *this; }
+	LDKCResult_NoneSendErrorZ* operator &() { return &self; }
+	LDKCResult_NoneSendErrorZ* operator ->() { return &self; }
+	const LDKCResult_NoneSendErrorZ* operator &() const { return &self; }
+	const LDKCResult_NoneSendErrorZ* operator ->() const { return &self; }
+};
 class CResult_FundingCreatedDecodeErrorZ {
 private:
 	LDKCResult_FundingCreatedDecodeErrorZ self;
@@ -4081,21 +4542,6 @@ public:
 	const LDKCResult_ChannelAnnouncementDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_ChannelAnnouncementDecodeErrorZ* operator ->() const { return &self; }
 };
-class CVec_OutPointZ {
-private:
-	LDKCVec_OutPointZ self;
-public:
-	CVec_OutPointZ(const CVec_OutPointZ&) = delete;
-	CVec_OutPointZ(CVec_OutPointZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_OutPointZ)); }
-	CVec_OutPointZ(LDKCVec_OutPointZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_OutPointZ)); }
-	operator LDKCVec_OutPointZ() && { LDKCVec_OutPointZ res = self; memset(&self, 0, sizeof(LDKCVec_OutPointZ)); return res; }
-	~CVec_OutPointZ() { CVec_OutPointZ_free(self); }
-	CVec_OutPointZ& operator=(CVec_OutPointZ&& o) { CVec_OutPointZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_OutPointZ)); return *this; }
-	LDKCVec_OutPointZ* operator &() { return &self; }
-	LDKCVec_OutPointZ* operator ->() { return &self; }
-	const LDKCVec_OutPointZ* operator &() const { return &self; }
-	const LDKCVec_OutPointZ* operator ->() const { return &self; }
-};
 class CResult_PositiveTimestampCreationErrorZ {
 private:
 	LDKCResult_PositiveTimestampCreationErrorZ self;
@@ -4111,6 +4557,21 @@ public:
 	const LDKCResult_PositiveTimestampCreationErrorZ* operator &() const { return &self; }
 	const LDKCResult_PositiveTimestampCreationErrorZ* operator ->() const { return &self; }
 };
+class CVec_OutPointZ {
+private:
+	LDKCVec_OutPointZ self;
+public:
+	CVec_OutPointZ(const CVec_OutPointZ&) = delete;
+	CVec_OutPointZ(CVec_OutPointZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_OutPointZ)); }
+	CVec_OutPointZ(LDKCVec_OutPointZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_OutPointZ)); }
+	operator LDKCVec_OutPointZ() && { LDKCVec_OutPointZ res = self; memset(&self, 0, sizeof(LDKCVec_OutPointZ)); return res; }
+	~CVec_OutPointZ() { CVec_OutPointZ_free(self); }
+	CVec_OutPointZ& operator=(CVec_OutPointZ&& o) { CVec_OutPointZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_OutPointZ)); return *this; }
+	LDKCVec_OutPointZ* operator &() { return &self; }
+	LDKCVec_OutPointZ* operator ->() { return &self; }
+	const LDKCVec_OutPointZ* operator &() const { return &self; }
+	const LDKCVec_OutPointZ* operator ->() const { return &self; }
+};
 class CResult_CVec_u8ZPeerHandleErrorZ {
 private:
 	LDKCResult_CVec_u8ZPeerHandleErrorZ self;
@@ -4276,6 +4737,21 @@ public:
 	const LDKCResult_NetAddressDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_NetAddressDecodeErrorZ* operator ->() const { return &self; }
 };
+class COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
+private:
+	LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ self;
+public:
+	COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(const COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&) = delete;
+	COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); }
+	COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); }
+	operator LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ() && { LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ res = self; memset(&self, 0, sizeof(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); return res; }
+	~COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ() { COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(self); }
+	COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ& operator=(COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&& o) { COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); return *this; }
+	LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator &() { return &self; }
+	LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator ->() { return &self; }
+	const LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator &() const { return &self; }
+	const LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator ->() const { return &self; }
+};
 class CResult_ChannelReestablishDecodeErrorZ {
 private:
 	LDKCResult_ChannelReestablishDecodeErrorZ self;
@@ -4291,21 +4767,6 @@ public:
 	const LDKCResult_ChannelReestablishDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_ChannelReestablishDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_CommitmentSignedDecodeErrorZ {
-private:
-	LDKCResult_CommitmentSignedDecodeErrorZ self;
-public:
-	CResult_CommitmentSignedDecodeErrorZ(const CResult_CommitmentSignedDecodeErrorZ&) = delete;
-	CResult_CommitmentSignedDecodeErrorZ(CResult_CommitmentSignedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CommitmentSignedDecodeErrorZ)); }
-	CResult_CommitmentSignedDecodeErrorZ(LDKCResult_CommitmentSignedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CommitmentSignedDecodeErrorZ)); }
-	operator LDKCResult_CommitmentSignedDecodeErrorZ() && { LDKCResult_CommitmentSignedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CommitmentSignedDecodeErrorZ)); return res; }
-	~CResult_CommitmentSignedDecodeErrorZ() { CResult_CommitmentSignedDecodeErrorZ_free(self); }
-	CResult_CommitmentSignedDecodeErrorZ& operator=(CResult_CommitmentSignedDecodeErrorZ&& o) { CResult_CommitmentSignedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CommitmentSignedDecodeErrorZ)); return *this; }
-	LDKCResult_CommitmentSignedDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_CommitmentSignedDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_CommitmentSignedDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_CommitmentSignedDecodeErrorZ* operator ->() const { return &self; }
-};
 class CVec_UpdateAddHTLCZ {
 private:
 	LDKCVec_UpdateAddHTLCZ self;
@@ -4321,20 +4782,20 @@ public:
 	const LDKCVec_UpdateAddHTLCZ* operator &() const { return &self; }
 	const LDKCVec_UpdateAddHTLCZ* operator ->() const { return &self; }
 };
-class CResult_UnsignedNodeAnnouncementDecodeErrorZ {
+class CResult_CommitmentSignedDecodeErrorZ {
 private:
-	LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ self;
+	LDKCResult_CommitmentSignedDecodeErrorZ self;
 public:
-	CResult_UnsignedNodeAnnouncementDecodeErrorZ(const CResult_UnsignedNodeAnnouncementDecodeErrorZ&) = delete;
-	CResult_UnsignedNodeAnnouncementDecodeErrorZ(CResult_UnsignedNodeAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnsignedNodeAnnouncementDecodeErrorZ)); }
-	CResult_UnsignedNodeAnnouncementDecodeErrorZ(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ)); }
-	operator LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ() && { LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ)); return res; }
-	~CResult_UnsignedNodeAnnouncementDecodeErrorZ() { CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(self); }
-	CResult_UnsignedNodeAnnouncementDecodeErrorZ& operator=(CResult_UnsignedNodeAnnouncementDecodeErrorZ&& o) { CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnsignedNodeAnnouncementDecodeErrorZ)); return *this; }
-	LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator ->() const { return &self; }
+	CResult_CommitmentSignedDecodeErrorZ(const CResult_CommitmentSignedDecodeErrorZ&) = delete;
+	CResult_CommitmentSignedDecodeErrorZ(CResult_CommitmentSignedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CommitmentSignedDecodeErrorZ)); }
+	CResult_CommitmentSignedDecodeErrorZ(LDKCResult_CommitmentSignedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CommitmentSignedDecodeErrorZ)); }
+	operator LDKCResult_CommitmentSignedDecodeErrorZ() && { LDKCResult_CommitmentSignedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CommitmentSignedDecodeErrorZ)); return res; }
+	~CResult_CommitmentSignedDecodeErrorZ() { CResult_CommitmentSignedDecodeErrorZ_free(self); }
+	CResult_CommitmentSignedDecodeErrorZ& operator=(CResult_CommitmentSignedDecodeErrorZ&& o) { CResult_CommitmentSignedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CommitmentSignedDecodeErrorZ)); return *this; }
+	LDKCResult_CommitmentSignedDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_CommitmentSignedDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_CommitmentSignedDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_CommitmentSignedDecodeErrorZ* operator ->() const { return &self; }
 };
 class COption_u32Z {
 private:
@@ -4381,6 +4842,21 @@ public:
 	const LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator ->() const { return &self; }
 };
+class CResult_PublicKeyNoneZ {
+private:
+	LDKCResult_PublicKeyNoneZ self;
+public:
+	CResult_PublicKeyNoneZ(const CResult_PublicKeyNoneZ&) = delete;
+	CResult_PublicKeyNoneZ(CResult_PublicKeyNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PublicKeyNoneZ)); }
+	CResult_PublicKeyNoneZ(LDKCResult_PublicKeyNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PublicKeyNoneZ)); }
+	operator LDKCResult_PublicKeyNoneZ() && { LDKCResult_PublicKeyNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_PublicKeyNoneZ)); return res; }
+	~CResult_PublicKeyNoneZ() { CResult_PublicKeyNoneZ_free(self); }
+	CResult_PublicKeyNoneZ& operator=(CResult_PublicKeyNoneZ&& o) { CResult_PublicKeyNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PublicKeyNoneZ)); return *this; }
+	LDKCResult_PublicKeyNoneZ* operator &() { return &self; }
+	LDKCResult_PublicKeyNoneZ* operator ->() { return &self; }
+	const LDKCResult_PublicKeyNoneZ* operator &() const { return &self; }
+	const LDKCResult_PublicKeyNoneZ* operator ->() const { return &self; }
+};
 class CResult_PaymentIdPaymentSendFailureZ {
 private:
 	LDKCResult_PaymentIdPaymentSendFailureZ self;
@@ -4396,21 +4872,6 @@ public:
 	const LDKCResult_PaymentIdPaymentSendFailureZ* operator &() const { return &self; }
 	const LDKCResult_PaymentIdPaymentSendFailureZ* operator ->() const { return &self; }
 };
-class CResult_ReplyChannelRangeDecodeErrorZ {
-private:
-	LDKCResult_ReplyChannelRangeDecodeErrorZ self;
-public:
-	CResult_ReplyChannelRangeDecodeErrorZ(const CResult_ReplyChannelRangeDecodeErrorZ&) = delete;
-	CResult_ReplyChannelRangeDecodeErrorZ(CResult_ReplyChannelRangeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ReplyChannelRangeDecodeErrorZ)); }
-	CResult_ReplyChannelRangeDecodeErrorZ(LDKCResult_ReplyChannelRangeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ)); }
-	operator LDKCResult_ReplyChannelRangeDecodeErrorZ() && { LDKCResult_ReplyChannelRangeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ)); return res; }
-	~CResult_ReplyChannelRangeDecodeErrorZ() { CResult_ReplyChannelRangeDecodeErrorZ_free(self); }
-	CResult_ReplyChannelRangeDecodeErrorZ& operator=(CResult_ReplyChannelRangeDecodeErrorZ&& o) { CResult_ReplyChannelRangeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ReplyChannelRangeDecodeErrorZ)); return *this; }
-	LDKCResult_ReplyChannelRangeDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_ReplyChannelRangeDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_ReplyChannelRangeDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_ReplyChannelRangeDecodeErrorZ* operator ->() const { return &self; }
-};
 class CResult_CommitmentTransactionDecodeErrorZ {
 private:
 	LDKCResult_CommitmentTransactionDecodeErrorZ self;
@@ -4426,21 +4887,6 @@ public:
 	const LDKCResult_CommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_CommitmentTransactionDecodeErrorZ* operator ->() const { return &self; }
 };
-class COption_C2Tuple_usizeTransactionZZ {
-private:
-	LDKCOption_C2Tuple_usizeTransactionZZ self;
-public:
-	COption_C2Tuple_usizeTransactionZZ(const COption_C2Tuple_usizeTransactionZZ&) = delete;
-	COption_C2Tuple_usizeTransactionZZ(COption_C2Tuple_usizeTransactionZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_C2Tuple_usizeTransactionZZ)); }
-	COption_C2Tuple_usizeTransactionZZ(LDKCOption_C2Tuple_usizeTransactionZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_C2Tuple_usizeTransactionZZ)); }
-	operator LDKCOption_C2Tuple_usizeTransactionZZ() && { LDKCOption_C2Tuple_usizeTransactionZZ res = self; memset(&self, 0, sizeof(LDKCOption_C2Tuple_usizeTransactionZZ)); return res; }
-	~COption_C2Tuple_usizeTransactionZZ() { COption_C2Tuple_usizeTransactionZZ_free(self); }
-	COption_C2Tuple_usizeTransactionZZ& operator=(COption_C2Tuple_usizeTransactionZZ&& o) { COption_C2Tuple_usizeTransactionZZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_C2Tuple_usizeTransactionZZ)); return *this; }
-	LDKCOption_C2Tuple_usizeTransactionZZ* operator &() { return &self; }
-	LDKCOption_C2Tuple_usizeTransactionZZ* operator ->() { return &self; }
-	const LDKCOption_C2Tuple_usizeTransactionZZ* operator &() const { return &self; }
-	const LDKCOption_C2Tuple_usizeTransactionZZ* operator ->() const { return &self; }
-};
 class CResult_TransactionNoneZ {
 private:
 	LDKCResult_TransactionNoneZ self;
@@ -4471,6 +4917,21 @@ public:
 	const LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator ->() const { return &self; }
 };
+class CResult_OnionMessageDecodeErrorZ {
+private:
+	LDKCResult_OnionMessageDecodeErrorZ self;
+public:
+	CResult_OnionMessageDecodeErrorZ(const CResult_OnionMessageDecodeErrorZ&) = delete;
+	CResult_OnionMessageDecodeErrorZ(CResult_OnionMessageDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OnionMessageDecodeErrorZ)); }
+	CResult_OnionMessageDecodeErrorZ(LDKCResult_OnionMessageDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OnionMessageDecodeErrorZ)); }
+	operator LDKCResult_OnionMessageDecodeErrorZ() && { LDKCResult_OnionMessageDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OnionMessageDecodeErrorZ)); return res; }
+	~CResult_OnionMessageDecodeErrorZ() { CResult_OnionMessageDecodeErrorZ_free(self); }
+	CResult_OnionMessageDecodeErrorZ& operator=(CResult_OnionMessageDecodeErrorZ&& o) { CResult_OnionMessageDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OnionMessageDecodeErrorZ)); return *this; }
+	LDKCResult_OnionMessageDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_OnionMessageDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_OnionMessageDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_OnionMessageDecodeErrorZ* operator ->() const { return &self; }
+};
 class CResult_PingDecodeErrorZ {
 private:
 	LDKCResult_PingDecodeErrorZ self;
@@ -4486,50 +4947,50 @@ public:
 	const LDKCResult_PingDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_PingDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_GossipTimestampFilterDecodeErrorZ {
+class CResult_UnsignedNodeAnnouncementDecodeErrorZ {
 private:
-	LDKCResult_GossipTimestampFilterDecodeErrorZ self;
+	LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ self;
 public:
-	CResult_GossipTimestampFilterDecodeErrorZ(const CResult_GossipTimestampFilterDecodeErrorZ&) = delete;
-	CResult_GossipTimestampFilterDecodeErrorZ(CResult_GossipTimestampFilterDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_GossipTimestampFilterDecodeErrorZ)); }
-	CResult_GossipTimestampFilterDecodeErrorZ(LDKCResult_GossipTimestampFilterDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ)); }
-	operator LDKCResult_GossipTimestampFilterDecodeErrorZ() && { LDKCResult_GossipTimestampFilterDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ)); return res; }
-	~CResult_GossipTimestampFilterDecodeErrorZ() { CResult_GossipTimestampFilterDecodeErrorZ_free(self); }
-	CResult_GossipTimestampFilterDecodeErrorZ& operator=(CResult_GossipTimestampFilterDecodeErrorZ&& o) { CResult_GossipTimestampFilterDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_GossipTimestampFilterDecodeErrorZ)); return *this; }
-	LDKCResult_GossipTimestampFilterDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_GossipTimestampFilterDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_GossipTimestampFilterDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_GossipTimestampFilterDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_InvoiceSignOrCreationErrorZ {
-private:
-	LDKCResult_InvoiceSignOrCreationErrorZ self;
+	CResult_UnsignedNodeAnnouncementDecodeErrorZ(const CResult_UnsignedNodeAnnouncementDecodeErrorZ&) = delete;
+	CResult_UnsignedNodeAnnouncementDecodeErrorZ(CResult_UnsignedNodeAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnsignedNodeAnnouncementDecodeErrorZ)); }
+	CResult_UnsignedNodeAnnouncementDecodeErrorZ(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ)); }
+	operator LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ() && { LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ)); return res; }
+	~CResult_UnsignedNodeAnnouncementDecodeErrorZ() { CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(self); }
+	CResult_UnsignedNodeAnnouncementDecodeErrorZ& operator=(CResult_UnsignedNodeAnnouncementDecodeErrorZ&& o) { CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnsignedNodeAnnouncementDecodeErrorZ)); return *this; }
+	LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_ReplyChannelRangeDecodeErrorZ {
+private:
+	LDKCResult_ReplyChannelRangeDecodeErrorZ self;
 public:
-	CResult_InvoiceSignOrCreationErrorZ(const CResult_InvoiceSignOrCreationErrorZ&) = delete;
-	CResult_InvoiceSignOrCreationErrorZ(CResult_InvoiceSignOrCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceSignOrCreationErrorZ)); }
-	CResult_InvoiceSignOrCreationErrorZ(LDKCResult_InvoiceSignOrCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceSignOrCreationErrorZ)); }
-	operator LDKCResult_InvoiceSignOrCreationErrorZ() && { LDKCResult_InvoiceSignOrCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceSignOrCreationErrorZ)); return res; }
-	~CResult_InvoiceSignOrCreationErrorZ() { CResult_InvoiceSignOrCreationErrorZ_free(self); }
-	CResult_InvoiceSignOrCreationErrorZ& operator=(CResult_InvoiceSignOrCreationErrorZ&& o) { CResult_InvoiceSignOrCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceSignOrCreationErrorZ)); return *this; }
-	LDKCResult_InvoiceSignOrCreationErrorZ* operator &() { return &self; }
-	LDKCResult_InvoiceSignOrCreationErrorZ* operator ->() { return &self; }
-	const LDKCResult_InvoiceSignOrCreationErrorZ* operator &() const { return &self; }
-	const LDKCResult_InvoiceSignOrCreationErrorZ* operator ->() const { return &self; }
+	CResult_ReplyChannelRangeDecodeErrorZ(const CResult_ReplyChannelRangeDecodeErrorZ&) = delete;
+	CResult_ReplyChannelRangeDecodeErrorZ(CResult_ReplyChannelRangeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ReplyChannelRangeDecodeErrorZ)); }
+	CResult_ReplyChannelRangeDecodeErrorZ(LDKCResult_ReplyChannelRangeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ)); }
+	operator LDKCResult_ReplyChannelRangeDecodeErrorZ() && { LDKCResult_ReplyChannelRangeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ)); return res; }
+	~CResult_ReplyChannelRangeDecodeErrorZ() { CResult_ReplyChannelRangeDecodeErrorZ_free(self); }
+	CResult_ReplyChannelRangeDecodeErrorZ& operator=(CResult_ReplyChannelRangeDecodeErrorZ&& o) { CResult_ReplyChannelRangeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ReplyChannelRangeDecodeErrorZ)); return *this; }
+	LDKCResult_ReplyChannelRangeDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_ReplyChannelRangeDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_ReplyChannelRangeDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_ReplyChannelRangeDecodeErrorZ* operator ->() const { return &self; }
 };
-class COption_FilterZ {
+class CResult_GossipTimestampFilterDecodeErrorZ {
 private:
-	LDKCOption_FilterZ self;
+	LDKCResult_GossipTimestampFilterDecodeErrorZ self;
 public:
-	COption_FilterZ(const COption_FilterZ&) = delete;
-	COption_FilterZ(COption_FilterZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_FilterZ)); }
-	COption_FilterZ(LDKCOption_FilterZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_FilterZ)); }
-	operator LDKCOption_FilterZ() && { LDKCOption_FilterZ res = self; memset(&self, 0, sizeof(LDKCOption_FilterZ)); return res; }
-	~COption_FilterZ() { COption_FilterZ_free(self); }
-	COption_FilterZ& operator=(COption_FilterZ&& o) { COption_FilterZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_FilterZ)); return *this; }
-	LDKCOption_FilterZ* operator &() { return &self; }
-	LDKCOption_FilterZ* operator ->() { return &self; }
-	const LDKCOption_FilterZ* operator &() const { return &self; }
-	const LDKCOption_FilterZ* operator ->() const { return &self; }
+	CResult_GossipTimestampFilterDecodeErrorZ(const CResult_GossipTimestampFilterDecodeErrorZ&) = delete;
+	CResult_GossipTimestampFilterDecodeErrorZ(CResult_GossipTimestampFilterDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_GossipTimestampFilterDecodeErrorZ)); }
+	CResult_GossipTimestampFilterDecodeErrorZ(LDKCResult_GossipTimestampFilterDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ)); }
+	operator LDKCResult_GossipTimestampFilterDecodeErrorZ() && { LDKCResult_GossipTimestampFilterDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ)); return res; }
+	~CResult_GossipTimestampFilterDecodeErrorZ() { CResult_GossipTimestampFilterDecodeErrorZ_free(self); }
+	CResult_GossipTimestampFilterDecodeErrorZ& operator=(CResult_GossipTimestampFilterDecodeErrorZ&& o) { CResult_GossipTimestampFilterDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_GossipTimestampFilterDecodeErrorZ)); return *this; }
+	LDKCResult_GossipTimestampFilterDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_GossipTimestampFilterDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_GossipTimestampFilterDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_GossipTimestampFilterDecodeErrorZ* operator ->() const { return &self; }
 };
 class CVec_TransactionOutputsZ {
 private:
@@ -4591,6 +5052,21 @@ public:
 	const LDKCVec_CVec_u8ZZ* operator &() const { return &self; }
 	const LDKCVec_CVec_u8ZZ* operator ->() const { return &self; }
 };
+class CResult_COption_CustomOnionMessageContentsZDecodeErrorZ {
+private:
+	LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ self;
+public:
+	CResult_COption_CustomOnionMessageContentsZDecodeErrorZ(const CResult_COption_CustomOnionMessageContentsZDecodeErrorZ&) = delete;
+	CResult_COption_CustomOnionMessageContentsZDecodeErrorZ(CResult_COption_CustomOnionMessageContentsZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_CustomOnionMessageContentsZDecodeErrorZ)); }
+	CResult_COption_CustomOnionMessageContentsZDecodeErrorZ(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ)); }
+	operator LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ() && { LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ)); return res; }
+	~CResult_COption_CustomOnionMessageContentsZDecodeErrorZ() { CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_free(self); }
+	CResult_COption_CustomOnionMessageContentsZDecodeErrorZ& operator=(CResult_COption_CustomOnionMessageContentsZDecodeErrorZ&& o) { CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_CustomOnionMessageContentsZDecodeErrorZ)); return *this; }
+	LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* operator ->() const { return &self; }
+};
 class CResult_SecretKeyErrorZ {
 private:
 	LDKCResult_SecretKeyErrorZ self;
@@ -4846,6 +5322,21 @@ public:
 	const LDKCResult_TxCreationKeysErrorZ* operator &() const { return &self; }
 	const LDKCResult_TxCreationKeysErrorZ* operator ->() const { return &self; }
 };
+class COption_HTLCDestinationZ {
+private:
+	LDKCOption_HTLCDestinationZ self;
+public:
+	COption_HTLCDestinationZ(const COption_HTLCDestinationZ&) = delete;
+	COption_HTLCDestinationZ(COption_HTLCDestinationZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_HTLCDestinationZ)); }
+	COption_HTLCDestinationZ(LDKCOption_HTLCDestinationZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_HTLCDestinationZ)); }
+	operator LDKCOption_HTLCDestinationZ() && { LDKCOption_HTLCDestinationZ res = self; memset(&self, 0, sizeof(LDKCOption_HTLCDestinationZ)); return res; }
+	~COption_HTLCDestinationZ() { COption_HTLCDestinationZ_free(self); }
+	COption_HTLCDestinationZ& operator=(COption_HTLCDestinationZ&& o) { COption_HTLCDestinationZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_HTLCDestinationZ)); return *this; }
+	LDKCOption_HTLCDestinationZ* operator &() { return &self; }
+	LDKCOption_HTLCDestinationZ* operator ->() { return &self; }
+	const LDKCOption_HTLCDestinationZ* operator &() const { return &self; }
+	const LDKCOption_HTLCDestinationZ* operator ->() const { return &self; }
+};
 class CResult_NodeIdDecodeErrorZ {
 private:
 	LDKCResult_NodeIdDecodeErrorZ self;
@@ -4861,21 +5352,6 @@ public:
 	const LDKCResult_NodeIdDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_NodeIdDecodeErrorZ* operator ->() const { return &self; }
 };
-class C2Tuple_BlockHashChannelMonitorZ {
-private:
-	LDKC2Tuple_BlockHashChannelMonitorZ self;
-public:
-	C2Tuple_BlockHashChannelMonitorZ(const C2Tuple_BlockHashChannelMonitorZ&) = delete;
-	C2Tuple_BlockHashChannelMonitorZ(C2Tuple_BlockHashChannelMonitorZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_BlockHashChannelMonitorZ)); }
-	C2Tuple_BlockHashChannelMonitorZ(LDKC2Tuple_BlockHashChannelMonitorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_BlockHashChannelMonitorZ)); }
-	operator LDKC2Tuple_BlockHashChannelMonitorZ() && { LDKC2Tuple_BlockHashChannelMonitorZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_BlockHashChannelMonitorZ)); return res; }
-	~C2Tuple_BlockHashChannelMonitorZ() { C2Tuple_BlockHashChannelMonitorZ_free(self); }
-	C2Tuple_BlockHashChannelMonitorZ& operator=(C2Tuple_BlockHashChannelMonitorZ&& o) { C2Tuple_BlockHashChannelMonitorZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_BlockHashChannelMonitorZ)); return *this; }
-	LDKC2Tuple_BlockHashChannelMonitorZ* operator &() { return &self; }
-	LDKC2Tuple_BlockHashChannelMonitorZ* operator ->() { return &self; }
-	const LDKC2Tuple_BlockHashChannelMonitorZ* operator &() const { return &self; }
-	const LDKC2Tuple_BlockHashChannelMonitorZ* operator ->() const { return &self; }
-};
 class CResult_ShutdownScriptInvalidShutdownScriptZ {
 private:
 	LDKCResult_ShutdownScriptInvalidShutdownScriptZ self;
@@ -4936,6 +5412,21 @@ public:
 	const LDKCResult_RecoverableSignatureNoneZ* operator &() const { return &self; }
 	const LDKCResult_RecoverableSignatureNoneZ* operator ->() const { return &self; }
 };
+class C2Tuple_BlockHashChannelMonitorZ {
+private:
+	LDKC2Tuple_BlockHashChannelMonitorZ self;
+public:
+	C2Tuple_BlockHashChannelMonitorZ(const C2Tuple_BlockHashChannelMonitorZ&) = delete;
+	C2Tuple_BlockHashChannelMonitorZ(C2Tuple_BlockHashChannelMonitorZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_BlockHashChannelMonitorZ)); }
+	C2Tuple_BlockHashChannelMonitorZ(LDKC2Tuple_BlockHashChannelMonitorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_BlockHashChannelMonitorZ)); }
+	operator LDKC2Tuple_BlockHashChannelMonitorZ() && { LDKC2Tuple_BlockHashChannelMonitorZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_BlockHashChannelMonitorZ)); return res; }
+	~C2Tuple_BlockHashChannelMonitorZ() { C2Tuple_BlockHashChannelMonitorZ_free(self); }
+	C2Tuple_BlockHashChannelMonitorZ& operator=(C2Tuple_BlockHashChannelMonitorZ&& o) { C2Tuple_BlockHashChannelMonitorZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_BlockHashChannelMonitorZ)); return *this; }
+	LDKC2Tuple_BlockHashChannelMonitorZ* operator &() { return &self; }
+	LDKC2Tuple_BlockHashChannelMonitorZ* operator ->() { return &self; }
+	const LDKC2Tuple_BlockHashChannelMonitorZ* operator &() const { return &self; }
+	const LDKC2Tuple_BlockHashChannelMonitorZ* operator ->() const { return &self; }
+};
 class C3Tuple_RawInvoice_u832InvoiceSignatureZ {
 private:
 	LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ self;
@@ -4996,6 +5487,21 @@ public:
 	const LDKCResult_NetworkGraphDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_NetworkGraphDecodeErrorZ* operator ->() const { return &self; }
 };
+class CResult_InvoiceSignOrCreationErrorZ {
+private:
+	LDKCResult_InvoiceSignOrCreationErrorZ self;
+public:
+	CResult_InvoiceSignOrCreationErrorZ(const CResult_InvoiceSignOrCreationErrorZ&) = delete;
+	CResult_InvoiceSignOrCreationErrorZ(CResult_InvoiceSignOrCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceSignOrCreationErrorZ)); }
+	CResult_InvoiceSignOrCreationErrorZ(LDKCResult_InvoiceSignOrCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceSignOrCreationErrorZ)); }
+	operator LDKCResult_InvoiceSignOrCreationErrorZ() && { LDKCResult_InvoiceSignOrCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceSignOrCreationErrorZ)); return res; }
+	~CResult_InvoiceSignOrCreationErrorZ() { CResult_InvoiceSignOrCreationErrorZ_free(self); }
+	CResult_InvoiceSignOrCreationErrorZ& operator=(CResult_InvoiceSignOrCreationErrorZ&& o) { CResult_InvoiceSignOrCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceSignOrCreationErrorZ)); return *this; }
+	LDKCResult_InvoiceSignOrCreationErrorZ* operator &() { return &self; }
+	LDKCResult_InvoiceSignOrCreationErrorZ* operator ->() { return &self; }
+	const LDKCResult_InvoiceSignOrCreationErrorZ* operator &() const { return &self; }
+	const LDKCResult_InvoiceSignOrCreationErrorZ* operator ->() const { return &self; }
+};
 class CVec_RouteHopZ {
 private:
 	LDKCVec_RouteHopZ self;
@@ -5011,20 +5517,35 @@ public:
 	const LDKCVec_RouteHopZ* operator &() const { return &self; }
 	const LDKCVec_RouteHopZ* operator ->() const { return &self; }
 };
-class CResult_NonePaymentSendFailureZ {
+class COption_FilterZ {
 private:
-	LDKCResult_NonePaymentSendFailureZ self;
+	LDKCOption_FilterZ self;
 public:
-	CResult_NonePaymentSendFailureZ(const CResult_NonePaymentSendFailureZ&) = delete;
-	CResult_NonePaymentSendFailureZ(CResult_NonePaymentSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NonePaymentSendFailureZ)); }
-	CResult_NonePaymentSendFailureZ(LDKCResult_NonePaymentSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NonePaymentSendFailureZ)); }
-	operator LDKCResult_NonePaymentSendFailureZ() && { LDKCResult_NonePaymentSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_NonePaymentSendFailureZ)); return res; }
-	~CResult_NonePaymentSendFailureZ() { CResult_NonePaymentSendFailureZ_free(self); }
-	CResult_NonePaymentSendFailureZ& operator=(CResult_NonePaymentSendFailureZ&& o) { CResult_NonePaymentSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NonePaymentSendFailureZ)); return *this; }
-	LDKCResult_NonePaymentSendFailureZ* operator &() { return &self; }
-	LDKCResult_NonePaymentSendFailureZ* operator ->() { return &self; }
-	const LDKCResult_NonePaymentSendFailureZ* operator &() const { return &self; }
-	const LDKCResult_NonePaymentSendFailureZ* operator ->() const { return &self; }
+	COption_FilterZ(const COption_FilterZ&) = delete;
+	COption_FilterZ(COption_FilterZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_FilterZ)); }
+	COption_FilterZ(LDKCOption_FilterZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_FilterZ)); }
+	operator LDKCOption_FilterZ() && { LDKCOption_FilterZ res = self; memset(&self, 0, sizeof(LDKCOption_FilterZ)); return res; }
+	~COption_FilterZ() { COption_FilterZ_free(self); }
+	COption_FilterZ& operator=(COption_FilterZ&& o) { COption_FilterZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_FilterZ)); return *this; }
+	LDKCOption_FilterZ* operator &() { return &self; }
+	LDKCOption_FilterZ* operator ->() { return &self; }
+	const LDKCOption_FilterZ* operator &() const { return &self; }
+	const LDKCOption_FilterZ* operator ->() const { return &self; }
+};
+class COption_CustomOnionMessageContentsZ {
+private:
+	LDKCOption_CustomOnionMessageContentsZ self;
+public:
+	COption_CustomOnionMessageContentsZ(const COption_CustomOnionMessageContentsZ&) = delete;
+	COption_CustomOnionMessageContentsZ(COption_CustomOnionMessageContentsZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_CustomOnionMessageContentsZ)); }
+	COption_CustomOnionMessageContentsZ(LDKCOption_CustomOnionMessageContentsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_CustomOnionMessageContentsZ)); }
+	operator LDKCOption_CustomOnionMessageContentsZ() && { LDKCOption_CustomOnionMessageContentsZ res = self; memset(&self, 0, sizeof(LDKCOption_CustomOnionMessageContentsZ)); return res; }
+	~COption_CustomOnionMessageContentsZ() { COption_CustomOnionMessageContentsZ_free(self); }
+	COption_CustomOnionMessageContentsZ& operator=(COption_CustomOnionMessageContentsZ&& o) { COption_CustomOnionMessageContentsZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_CustomOnionMessageContentsZ)); return *this; }
+	LDKCOption_CustomOnionMessageContentsZ* operator &() { return &self; }
+	LDKCOption_CustomOnionMessageContentsZ* operator ->() { return &self; }
+	const LDKCOption_CustomOnionMessageContentsZ* operator &() const { return &self; }
+	const LDKCOption_CustomOnionMessageContentsZ* operator ->() const { return &self; }
 };
 class CResult_NodeInfoDecodeErrorZ {
 private:
@@ -5041,6 +5562,21 @@ public:
 	const LDKCResult_NodeInfoDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_NodeInfoDecodeErrorZ* operator ->() const { return &self; }
 };
+class CVec_NodeIdZ {
+private:
+	LDKCVec_NodeIdZ self;
+public:
+	CVec_NodeIdZ(const CVec_NodeIdZ&) = delete;
+	CVec_NodeIdZ(CVec_NodeIdZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_NodeIdZ)); }
+	CVec_NodeIdZ(LDKCVec_NodeIdZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_NodeIdZ)); }
+	operator LDKCVec_NodeIdZ() && { LDKCVec_NodeIdZ res = self; memset(&self, 0, sizeof(LDKCVec_NodeIdZ)); return res; }
+	~CVec_NodeIdZ() { CVec_NodeIdZ_free(self); }
+	CVec_NodeIdZ& operator=(CVec_NodeIdZ&& o) { CVec_NodeIdZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_NodeIdZ)); return *this; }
+	LDKCVec_NodeIdZ* operator &() { return &self; }
+	LDKCVec_NodeIdZ* operator ->() { return &self; }
+	const LDKCVec_NodeIdZ* operator &() const { return &self; }
+	const LDKCVec_NodeIdZ* operator ->() const { return &self; }
+};
 class CResult_RouteLightningErrorZ {
 private:
 	LDKCResult_RouteLightningErrorZ self;
@@ -5071,21 +5607,6 @@ public:
 	const LDKCResult_ChannelPublicKeysDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_ChannelPublicKeysDecodeErrorZ* operator ->() const { return &self; }
 };
-class CVec_NodeIdZ {
-private:
-	LDKCVec_NodeIdZ self;
-public:
-	CVec_NodeIdZ(const CVec_NodeIdZ&) = delete;
-	CVec_NodeIdZ(CVec_NodeIdZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_NodeIdZ)); }
-	CVec_NodeIdZ(LDKCVec_NodeIdZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_NodeIdZ)); }
-	operator LDKCVec_NodeIdZ() && { LDKCVec_NodeIdZ res = self; memset(&self, 0, sizeof(LDKCVec_NodeIdZ)); return res; }
-	~CVec_NodeIdZ() { CVec_NodeIdZ_free(self); }
-	CVec_NodeIdZ& operator=(CVec_NodeIdZ&& o) { CVec_NodeIdZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_NodeIdZ)); return *this; }
-	LDKCVec_NodeIdZ* operator &() { return &self; }
-	LDKCVec_NodeIdZ* operator ->() { return &self; }
-	const LDKCVec_NodeIdZ* operator &() const { return &self; }
-	const LDKCVec_NodeIdZ* operator ->() const { return &self; }
-};
 class CVec_u8Z {
 private:
 	LDKCVec_u8Z self;
@@ -5116,6 +5637,21 @@ public:
 	const LDKCVec_C2Tuple_BlockHashChannelMonitorZZ* operator &() const { return &self; }
 	const LDKCVec_C2Tuple_BlockHashChannelMonitorZZ* operator ->() const { return &self; }
 };
+class CResult_NonePaymentSendFailureZ {
+private:
+	LDKCResult_NonePaymentSendFailureZ self;
+public:
+	CResult_NonePaymentSendFailureZ(const CResult_NonePaymentSendFailureZ&) = delete;
+	CResult_NonePaymentSendFailureZ(CResult_NonePaymentSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NonePaymentSendFailureZ)); }
+	CResult_NonePaymentSendFailureZ(LDKCResult_NonePaymentSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NonePaymentSendFailureZ)); }
+	operator LDKCResult_NonePaymentSendFailureZ() && { LDKCResult_NonePaymentSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_NonePaymentSendFailureZ)); return res; }
+	~CResult_NonePaymentSendFailureZ() { CResult_NonePaymentSendFailureZ_free(self); }
+	CResult_NonePaymentSendFailureZ& operator=(CResult_NonePaymentSendFailureZ&& o) { CResult_NonePaymentSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NonePaymentSendFailureZ)); return *this; }
+	LDKCResult_NonePaymentSendFailureZ* operator &() { return &self; }
+	LDKCResult_NonePaymentSendFailureZ* operator ->() { return &self; }
+	const LDKCResult_NonePaymentSendFailureZ* operator &() const { return &self; }
+	const LDKCResult_NonePaymentSendFailureZ* operator ->() const { return &self; }
+};
 class CVec_ThirtyTwoBytesZ {
 private:
 	LDKCVec_ThirtyTwoBytesZ self;
@@ -5146,21 +5682,6 @@ public:
 	const LDKCResult_ClosingSignedDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_ClosingSignedDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_HolderCommitmentTransactionDecodeErrorZ {
-private:
-	LDKCResult_HolderCommitmentTransactionDecodeErrorZ self;
-public:
-	CResult_HolderCommitmentTransactionDecodeErrorZ(const CResult_HolderCommitmentTransactionDecodeErrorZ&) = delete;
-	CResult_HolderCommitmentTransactionDecodeErrorZ(CResult_HolderCommitmentTransactionDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HolderCommitmentTransactionDecodeErrorZ)); }
-	CResult_HolderCommitmentTransactionDecodeErrorZ(LDKCResult_HolderCommitmentTransactionDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ)); }
-	operator LDKCResult_HolderCommitmentTransactionDecodeErrorZ() && { LDKCResult_HolderCommitmentTransactionDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ)); return res; }
-	~CResult_HolderCommitmentTransactionDecodeErrorZ() { CResult_HolderCommitmentTransactionDecodeErrorZ_free(self); }
-	CResult_HolderCommitmentTransactionDecodeErrorZ& operator=(CResult_HolderCommitmentTransactionDecodeErrorZ&& o) { CResult_HolderCommitmentTransactionDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HolderCommitmentTransactionDecodeErrorZ)); return *this; }
-	LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator ->() const { return &self; }
-};
 class CVec_CResult_NoneAPIErrorZZ {
 private:
 	LDKCVec_CResult_NoneAPIErrorZZ self;
@@ -5176,6 +5697,21 @@ public:
 	const LDKCVec_CResult_NoneAPIErrorZZ* operator &() const { return &self; }
 	const LDKCVec_CResult_NoneAPIErrorZZ* operator ->() const { return &self; }
 };
+class CResult_HolderCommitmentTransactionDecodeErrorZ {
+private:
+	LDKCResult_HolderCommitmentTransactionDecodeErrorZ self;
+public:
+	CResult_HolderCommitmentTransactionDecodeErrorZ(const CResult_HolderCommitmentTransactionDecodeErrorZ&) = delete;
+	CResult_HolderCommitmentTransactionDecodeErrorZ(CResult_HolderCommitmentTransactionDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HolderCommitmentTransactionDecodeErrorZ)); }
+	CResult_HolderCommitmentTransactionDecodeErrorZ(LDKCResult_HolderCommitmentTransactionDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ)); }
+	operator LDKCResult_HolderCommitmentTransactionDecodeErrorZ() && { LDKCResult_HolderCommitmentTransactionDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ)); return res; }
+	~CResult_HolderCommitmentTransactionDecodeErrorZ() { CResult_HolderCommitmentTransactionDecodeErrorZ_free(self); }
+	CResult_HolderCommitmentTransactionDecodeErrorZ& operator=(CResult_HolderCommitmentTransactionDecodeErrorZ&& o) { CResult_HolderCommitmentTransactionDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HolderCommitmentTransactionDecodeErrorZ)); return *this; }
+	LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator ->() const { return &self; }
+};
 class CResult_CounterpartyCommitmentSecretsDecodeErrorZ {
 private:
 	LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ self;
@@ -5356,6 +5892,21 @@ public:
 	const LDKCResult_OutPointDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_OutPointDecodeErrorZ* operator ->() const { return &self; }
 };
+class CResult_BlindedRouteDecodeErrorZ {
+private:
+	LDKCResult_BlindedRouteDecodeErrorZ self;
+public:
+	CResult_BlindedRouteDecodeErrorZ(const CResult_BlindedRouteDecodeErrorZ&) = delete;
+	CResult_BlindedRouteDecodeErrorZ(CResult_BlindedRouteDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedRouteDecodeErrorZ)); }
+	CResult_BlindedRouteDecodeErrorZ(LDKCResult_BlindedRouteDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedRouteDecodeErrorZ)); }
+	operator LDKCResult_BlindedRouteDecodeErrorZ() && { LDKCResult_BlindedRouteDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedRouteDecodeErrorZ)); return res; }
+	~CResult_BlindedRouteDecodeErrorZ() { CResult_BlindedRouteDecodeErrorZ_free(self); }
+	CResult_BlindedRouteDecodeErrorZ& operator=(CResult_BlindedRouteDecodeErrorZ&& o) { CResult_BlindedRouteDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedRouteDecodeErrorZ)); return *this; }
+	LDKCResult_BlindedRouteDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_BlindedRouteDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_BlindedRouteDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_BlindedRouteDecodeErrorZ* operator ->() const { return &self; }
+};
 class CVec_ChannelDetailsZ {
 private:
 	LDKCVec_ChannelDetailsZ self;
@@ -5371,36 +5922,6 @@ public:
 	const LDKCVec_ChannelDetailsZ* operator &() const { return &self; }
 	const LDKCVec_ChannelDetailsZ* operator ->() const { return &self; }
 };
-class CResult_SignDecodeErrorZ {
-private:
-	LDKCResult_SignDecodeErrorZ self;
-public:
-	CResult_SignDecodeErrorZ(const CResult_SignDecodeErrorZ&) = delete;
-	CResult_SignDecodeErrorZ(CResult_SignDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SignDecodeErrorZ)); }
-	CResult_SignDecodeErrorZ(LDKCResult_SignDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SignDecodeErrorZ)); }
-	operator LDKCResult_SignDecodeErrorZ() && { LDKCResult_SignDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SignDecodeErrorZ)); return res; }
-	~CResult_SignDecodeErrorZ() { CResult_SignDecodeErrorZ_free(self); }
-	CResult_SignDecodeErrorZ& operator=(CResult_SignDecodeErrorZ&& o) { CResult_SignDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SignDecodeErrorZ)); return *this; }
-	LDKCResult_SignDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_SignDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_SignDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_SignDecodeErrorZ* operator ->() const { return &self; }
-};
-class C2Tuple_OutPointCVec_MonitorEventZZ {
-private:
-	LDKC2Tuple_OutPointCVec_MonitorEventZZ self;
-public:
-	C2Tuple_OutPointCVec_MonitorEventZZ(const C2Tuple_OutPointCVec_MonitorEventZZ&) = delete;
-	C2Tuple_OutPointCVec_MonitorEventZZ(C2Tuple_OutPointCVec_MonitorEventZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_OutPointCVec_MonitorEventZZ)); }
-	C2Tuple_OutPointCVec_MonitorEventZZ(LDKC2Tuple_OutPointCVec_MonitorEventZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_OutPointCVec_MonitorEventZZ)); }
-	operator LDKC2Tuple_OutPointCVec_MonitorEventZZ() && { LDKC2Tuple_OutPointCVec_MonitorEventZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_OutPointCVec_MonitorEventZZ)); return res; }
-	~C2Tuple_OutPointCVec_MonitorEventZZ() { C2Tuple_OutPointCVec_MonitorEventZZ_free(self); }
-	C2Tuple_OutPointCVec_MonitorEventZZ& operator=(C2Tuple_OutPointCVec_MonitorEventZZ&& o) { C2Tuple_OutPointCVec_MonitorEventZZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_OutPointCVec_MonitorEventZZ)); return *this; }
-	LDKC2Tuple_OutPointCVec_MonitorEventZZ* operator &() { return &self; }
-	LDKC2Tuple_OutPointCVec_MonitorEventZZ* operator ->() { return &self; }
-	const LDKC2Tuple_OutPointCVec_MonitorEventZZ* operator &() const { return &self; }
-	const LDKC2Tuple_OutPointCVec_MonitorEventZZ* operator ->() const { return &self; }
-};
 class CVec_MessageSendEventZ {
 private:
 	LDKCVec_MessageSendEventZ self;
@@ -5416,6 +5937,21 @@ public:
 	const LDKCVec_MessageSendEventZ* operator &() const { return &self; }
 	const LDKCVec_MessageSendEventZ* operator ->() const { return &self; }
 };
+class CResult_SignDecodeErrorZ {
+private:
+	LDKCResult_SignDecodeErrorZ self;
+public:
+	CResult_SignDecodeErrorZ(const CResult_SignDecodeErrorZ&) = delete;
+	CResult_SignDecodeErrorZ(CResult_SignDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SignDecodeErrorZ)); }
+	CResult_SignDecodeErrorZ(LDKCResult_SignDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SignDecodeErrorZ)); }
+	operator LDKCResult_SignDecodeErrorZ() && { LDKCResult_SignDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SignDecodeErrorZ)); return res; }
+	~CResult_SignDecodeErrorZ() { CResult_SignDecodeErrorZ_free(self); }
+	CResult_SignDecodeErrorZ& operator=(CResult_SignDecodeErrorZ&& o) { CResult_SignDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SignDecodeErrorZ)); return *this; }
+	LDKCResult_SignDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_SignDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_SignDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_SignDecodeErrorZ* operator ->() const { return &self; }
+};
 class COption_NetAddressZ {
 private:
 	LDKCOption_NetAddressZ self;
@@ -5476,21 +6012,6 @@ public:
 	const LDKCResult_C2Tuple_SignatureSignatureZNoneZ* operator &() const { return &self; }
 	const LDKCResult_C2Tuple_SignatureSignatureZNoneZ* operator ->() const { return &self; }
 };
-class CVec_NodeAnnouncementZ {
-private:
-	LDKCVec_NodeAnnouncementZ self;
-public:
-	CVec_NodeAnnouncementZ(const CVec_NodeAnnouncementZ&) = delete;
-	CVec_NodeAnnouncementZ(CVec_NodeAnnouncementZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_NodeAnnouncementZ)); }
-	CVec_NodeAnnouncementZ(LDKCVec_NodeAnnouncementZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_NodeAnnouncementZ)); }
-	operator LDKCVec_NodeAnnouncementZ() && { LDKCVec_NodeAnnouncementZ res = self; memset(&self, 0, sizeof(LDKCVec_NodeAnnouncementZ)); return res; }
-	~CVec_NodeAnnouncementZ() { CVec_NodeAnnouncementZ_free(self); }
-	CVec_NodeAnnouncementZ& operator=(CVec_NodeAnnouncementZ&& o) { CVec_NodeAnnouncementZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_NodeAnnouncementZ)); return *this; }
-	LDKCVec_NodeAnnouncementZ* operator &() { return &self; }
-	LDKCVec_NodeAnnouncementZ* operator ->() { return &self; }
-	const LDKCVec_NodeAnnouncementZ* operator &() const { return &self; }
-	const LDKCVec_NodeAnnouncementZ* operator ->() const { return &self; }
-};
 class CResult_UpdateFailMalformedHTLCDecodeErrorZ {
 private:
 	LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ self;
@@ -5506,20 +6027,20 @@ public:
 	const LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_UnsignedChannelAnnouncementDecodeErrorZ {
+class CResult_SharedSecretNoneZ {
 private:
-	LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ self;
+	LDKCResult_SharedSecretNoneZ self;
 public:
-	CResult_UnsignedChannelAnnouncementDecodeErrorZ(const CResult_UnsignedChannelAnnouncementDecodeErrorZ&) = delete;
-	CResult_UnsignedChannelAnnouncementDecodeErrorZ(CResult_UnsignedChannelAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnsignedChannelAnnouncementDecodeErrorZ)); }
-	CResult_UnsignedChannelAnnouncementDecodeErrorZ(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ)); }
-	operator LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ() && { LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ)); return res; }
-	~CResult_UnsignedChannelAnnouncementDecodeErrorZ() { CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(self); }
-	CResult_UnsignedChannelAnnouncementDecodeErrorZ& operator=(CResult_UnsignedChannelAnnouncementDecodeErrorZ&& o) { CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnsignedChannelAnnouncementDecodeErrorZ)); return *this; }
-	LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator ->() const { return &self; }
+	CResult_SharedSecretNoneZ(const CResult_SharedSecretNoneZ&) = delete;
+	CResult_SharedSecretNoneZ(CResult_SharedSecretNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SharedSecretNoneZ)); }
+	CResult_SharedSecretNoneZ(LDKCResult_SharedSecretNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SharedSecretNoneZ)); }
+	operator LDKCResult_SharedSecretNoneZ() && { LDKCResult_SharedSecretNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_SharedSecretNoneZ)); return res; }
+	~CResult_SharedSecretNoneZ() { CResult_SharedSecretNoneZ_free(self); }
+	CResult_SharedSecretNoneZ& operator=(CResult_SharedSecretNoneZ&& o) { CResult_SharedSecretNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SharedSecretNoneZ)); return *this; }
+	LDKCResult_SharedSecretNoneZ* operator &() { return &self; }
+	LDKCResult_SharedSecretNoneZ* operator ->() { return &self; }
+	const LDKCResult_SharedSecretNoneZ* operator &() const { return &self; }
+	const LDKCResult_SharedSecretNoneZ* operator ->() const { return &self; }
 };
 class CVec_TxidZ {
 private:
@@ -5566,21 +6087,6 @@ public:
 	const LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* operator &() const { return &self; }
 	const LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* operator ->() const { return &self; }
 };
-class CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
-private:
-	LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ self;
-public:
-	CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(const CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&) = delete;
-	CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); }
-	CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); }
-	operator LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ() && { LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ res = self; memset(&self, 0, sizeof(LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); return res; }
-	~CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ() { CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(self); }
-	CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ& operator=(CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&& o) { CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); return *this; }
-	LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator &() { return &self; }
-	LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator ->() { return &self; }
-	const LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator &() const { return &self; }
-	const LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator ->() const { return &self; }
-};
 class CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ {
 private:
 	LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ self;
@@ -5596,6 +6102,21 @@ public:
 	const LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* operator ->() const { return &self; }
 };
+class CResult_PongDecodeErrorZ {
+private:
+	LDKCResult_PongDecodeErrorZ self;
+public:
+	CResult_PongDecodeErrorZ(const CResult_PongDecodeErrorZ&) = delete;
+	CResult_PongDecodeErrorZ(CResult_PongDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PongDecodeErrorZ)); }
+	CResult_PongDecodeErrorZ(LDKCResult_PongDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PongDecodeErrorZ)); }
+	operator LDKCResult_PongDecodeErrorZ() && { LDKCResult_PongDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PongDecodeErrorZ)); return res; }
+	~CResult_PongDecodeErrorZ() { CResult_PongDecodeErrorZ_free(self); }
+	CResult_PongDecodeErrorZ& operator=(CResult_PongDecodeErrorZ&& o) { CResult_PongDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PongDecodeErrorZ)); return *this; }
+	LDKCResult_PongDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_PongDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_PongDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_PongDecodeErrorZ* operator ->() const { return &self; }
+};
 class CResult_CVec_CVec_u8ZZNoneZ {
 private:
 	LDKCResult_CVec_CVec_u8ZZNoneZ self;
@@ -5716,20 +6237,20 @@ public:
 	const LDKCVec_u64Z* operator &() const { return &self; }
 	const LDKCVec_u64Z* operator ->() const { return &self; }
 };
-class CResult_PongDecodeErrorZ {
+class CResult_UnsignedChannelAnnouncementDecodeErrorZ {
 private:
-	LDKCResult_PongDecodeErrorZ self;
+	LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ self;
 public:
-	CResult_PongDecodeErrorZ(const CResult_PongDecodeErrorZ&) = delete;
-	CResult_PongDecodeErrorZ(CResult_PongDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PongDecodeErrorZ)); }
-	CResult_PongDecodeErrorZ(LDKCResult_PongDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PongDecodeErrorZ)); }
-	operator LDKCResult_PongDecodeErrorZ() && { LDKCResult_PongDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PongDecodeErrorZ)); return res; }
-	~CResult_PongDecodeErrorZ() { CResult_PongDecodeErrorZ_free(self); }
-	CResult_PongDecodeErrorZ& operator=(CResult_PongDecodeErrorZ&& o) { CResult_PongDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PongDecodeErrorZ)); return *this; }
-	LDKCResult_PongDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_PongDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_PongDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_PongDecodeErrorZ* operator ->() const { return &self; }
+	CResult_UnsignedChannelAnnouncementDecodeErrorZ(const CResult_UnsignedChannelAnnouncementDecodeErrorZ&) = delete;
+	CResult_UnsignedChannelAnnouncementDecodeErrorZ(CResult_UnsignedChannelAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnsignedChannelAnnouncementDecodeErrorZ)); }
+	CResult_UnsignedChannelAnnouncementDecodeErrorZ(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ)); }
+	operator LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ() && { LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ)); return res; }
+	~CResult_UnsignedChannelAnnouncementDecodeErrorZ() { CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(self); }
+	CResult_UnsignedChannelAnnouncementDecodeErrorZ& operator=(CResult_UnsignedChannelAnnouncementDecodeErrorZ&& o) { CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnsignedChannelAnnouncementDecodeErrorZ)); return *this; }
+	LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator ->() const { return &self; }
 };
 class CResult_DelayedPaymentOutputDescriptorDecodeErrorZ {
 private:
@@ -5791,6 +6312,36 @@ public:
 	const LDKCResult_NoneErrorZ* operator &() const { return &self; }
 	const LDKCResult_NoneErrorZ* operator ->() const { return &self; }
 };
+class CResult_COption_HTLCDestinationZDecodeErrorZ {
+private:
+	LDKCResult_COption_HTLCDestinationZDecodeErrorZ self;
+public:
+	CResult_COption_HTLCDestinationZDecodeErrorZ(const CResult_COption_HTLCDestinationZDecodeErrorZ&) = delete;
+	CResult_COption_HTLCDestinationZDecodeErrorZ(CResult_COption_HTLCDestinationZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_HTLCDestinationZDecodeErrorZ)); }
+	CResult_COption_HTLCDestinationZDecodeErrorZ(LDKCResult_COption_HTLCDestinationZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_HTLCDestinationZDecodeErrorZ)); }
+	operator LDKCResult_COption_HTLCDestinationZDecodeErrorZ() && { LDKCResult_COption_HTLCDestinationZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_HTLCDestinationZDecodeErrorZ)); return res; }
+	~CResult_COption_HTLCDestinationZDecodeErrorZ() { CResult_COption_HTLCDestinationZDecodeErrorZ_free(self); }
+	CResult_COption_HTLCDestinationZDecodeErrorZ& operator=(CResult_COption_HTLCDestinationZDecodeErrorZ&& o) { CResult_COption_HTLCDestinationZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_HTLCDestinationZDecodeErrorZ)); return *this; }
+	LDKCResult_COption_HTLCDestinationZDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_COption_HTLCDestinationZDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_COption_HTLCDestinationZDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_COption_HTLCDestinationZDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_InFlightHtlcsDecodeErrorZ {
+private:
+	LDKCResult_InFlightHtlcsDecodeErrorZ self;
+public:
+	CResult_InFlightHtlcsDecodeErrorZ(const CResult_InFlightHtlcsDecodeErrorZ&) = delete;
+	CResult_InFlightHtlcsDecodeErrorZ(CResult_InFlightHtlcsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InFlightHtlcsDecodeErrorZ)); }
+	CResult_InFlightHtlcsDecodeErrorZ(LDKCResult_InFlightHtlcsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InFlightHtlcsDecodeErrorZ)); }
+	operator LDKCResult_InFlightHtlcsDecodeErrorZ() && { LDKCResult_InFlightHtlcsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InFlightHtlcsDecodeErrorZ)); return res; }
+	~CResult_InFlightHtlcsDecodeErrorZ() { CResult_InFlightHtlcsDecodeErrorZ_free(self); }
+	CResult_InFlightHtlcsDecodeErrorZ& operator=(CResult_InFlightHtlcsDecodeErrorZ&& o) { CResult_InFlightHtlcsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InFlightHtlcsDecodeErrorZ)); return *this; }
+	LDKCResult_InFlightHtlcsDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_InFlightHtlcsDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_InFlightHtlcsDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_InFlightHtlcsDecodeErrorZ* operator ->() const { return &self; }
+};
 class CResult_StringErrorZ {
 private:
 	LDKCResult_StringErrorZ self;
@@ -5806,21 +6357,6 @@ public:
 	const LDKCResult_StringErrorZ* operator &() const { return &self; }
 	const LDKCResult_StringErrorZ* operator ->() const { return &self; }
 };
-class C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ {
-private:
-	LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ self;
-public:
-	C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ(const C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ&) = delete;
-	C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ(C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ)); }
-	C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ)); }
-	operator LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ() && { LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ)); return res; }
-	~C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ() { C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(self); }
-	C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ& operator=(C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ&& o) { C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ)); return *this; }
-	LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* operator &() { return &self; }
-	LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* operator ->() { return &self; }
-	const LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* operator &() const { return &self; }
-	const LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* operator ->() const { return &self; }
-};
 class CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ {
 private:
 	LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ self;
@@ -5851,6 +6387,21 @@ public:
 	const LDKCOption_EventZ* operator &() const { return &self; }
 	const LDKCOption_EventZ* operator ->() const { return &self; }
 };
+class C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ {
+private:
+	LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ self;
+public:
+	C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ(const C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ&) = delete;
+	C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ(C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ)); }
+	C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ)); }
+	operator LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ() && { LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ)); return res; }
+	~C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ() { C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(self); }
+	C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ& operator=(C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ&& o) { C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ)); return *this; }
+	LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* operator &() { return &self; }
+	LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* operator ->() { return &self; }
+	const LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* operator &() const { return &self; }
+	const LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* operator ->() const { return &self; }
+};
 class CResult_ChannelTypeFeaturesDecodeErrorZ {
 private:
 	LDKCResult_ChannelTypeFeaturesDecodeErrorZ self;
@@ -5911,6 +6462,21 @@ public:
 	const LDKCOption_u16Z* operator &() const { return &self; }
 	const LDKCOption_u16Z* operator ->() const { return &self; }
 };
+class CResult_BlindedHopDecodeErrorZ {
+private:
+	LDKCResult_BlindedHopDecodeErrorZ self;
+public:
+	CResult_BlindedHopDecodeErrorZ(const CResult_BlindedHopDecodeErrorZ&) = delete;
+	CResult_BlindedHopDecodeErrorZ(CResult_BlindedHopDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedHopDecodeErrorZ)); }
+	CResult_BlindedHopDecodeErrorZ(LDKCResult_BlindedHopDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedHopDecodeErrorZ)); }
+	operator LDKCResult_BlindedHopDecodeErrorZ() && { LDKCResult_BlindedHopDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedHopDecodeErrorZ)); return res; }
+	~CResult_BlindedHopDecodeErrorZ() { CResult_BlindedHopDecodeErrorZ_free(self); }
+	CResult_BlindedHopDecodeErrorZ& operator=(CResult_BlindedHopDecodeErrorZ&& o) { CResult_BlindedHopDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedHopDecodeErrorZ)); return *this; }
+	LDKCResult_BlindedHopDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_BlindedHopDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_BlindedHopDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_BlindedHopDecodeErrorZ* operator ->() const { return &self; }
+};
 class CVec_CVec_RouteHopZZ {
 private:
 	LDKCVec_CVec_RouteHopZZ self;
@@ -6121,6 +6687,21 @@ public:
 	const LDKCResult_COption_MonitorEventZDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_COption_MonitorEventZDecodeErrorZ* operator ->() const { return &self; }
 };
+class C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ {
+private:
+	LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ self;
+public:
+	C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ(const C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ&) = delete;
+	C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ(C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ)); }
+	C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ)); }
+	operator LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ() && { LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ)); return res; }
+	~C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ() { C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(self); }
+	C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ& operator=(C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ&& o) { C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(self); self = o.self; memset(&o, 0, sizeof(C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ)); return *this; }
+	LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* operator &() { return &self; }
+	LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* operator ->() { return &self; }
+	const LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* operator &() const { return &self; }
+	const LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* operator ->() const { return &self; }
+};
 class CVec_C2Tuple_PublicKeyTypeZZ {
 private:
 	LDKCVec_C2Tuple_PublicKeyTypeZZ self;
@@ -6136,21 +6717,6 @@ public:
 	const LDKCVec_C2Tuple_PublicKeyTypeZZ* operator &() const { return &self; }
 	const LDKCVec_C2Tuple_PublicKeyTypeZZ* operator ->() const { return &self; }
 };
-class CResult_u32GraphSyncErrorZ {
-private:
-	LDKCResult_u32GraphSyncErrorZ self;
-public:
-	CResult_u32GraphSyncErrorZ(const CResult_u32GraphSyncErrorZ&) = delete;
-	CResult_u32GraphSyncErrorZ(CResult_u32GraphSyncErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_u32GraphSyncErrorZ)); }
-	CResult_u32GraphSyncErrorZ(LDKCResult_u32GraphSyncErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_u32GraphSyncErrorZ)); }
-	operator LDKCResult_u32GraphSyncErrorZ() && { LDKCResult_u32GraphSyncErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_u32GraphSyncErrorZ)); return res; }
-	~CResult_u32GraphSyncErrorZ() { CResult_u32GraphSyncErrorZ_free(self); }
-	CResult_u32GraphSyncErrorZ& operator=(CResult_u32GraphSyncErrorZ&& o) { CResult_u32GraphSyncErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_u32GraphSyncErrorZ)); return *this; }
-	LDKCResult_u32GraphSyncErrorZ* operator &() { return &self; }
-	LDKCResult_u32GraphSyncErrorZ* operator ->() { return &self; }
-	const LDKCResult_u32GraphSyncErrorZ* operator &() const { return &self; }
-	const LDKCResult_u32GraphSyncErrorZ* operator ->() const { return &self; }
-};
 class CResult_InvoiceSemanticErrorZ {
 private:
 	LDKCResult_InvoiceSemanticErrorZ self;
@@ -6166,6 +6732,21 @@ public:
 	const LDKCResult_InvoiceSemanticErrorZ* operator &() const { return &self; }
 	const LDKCResult_InvoiceSemanticErrorZ* operator ->() const { return &self; }
 };
+class CResult_u32GraphSyncErrorZ {
+private:
+	LDKCResult_u32GraphSyncErrorZ self;
+public:
+	CResult_u32GraphSyncErrorZ(const CResult_u32GraphSyncErrorZ&) = delete;
+	CResult_u32GraphSyncErrorZ(CResult_u32GraphSyncErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_u32GraphSyncErrorZ)); }
+	CResult_u32GraphSyncErrorZ(LDKCResult_u32GraphSyncErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_u32GraphSyncErrorZ)); }
+	operator LDKCResult_u32GraphSyncErrorZ() && { LDKCResult_u32GraphSyncErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_u32GraphSyncErrorZ)); return res; }
+	~CResult_u32GraphSyncErrorZ() { CResult_u32GraphSyncErrorZ_free(self); }
+	CResult_u32GraphSyncErrorZ& operator=(CResult_u32GraphSyncErrorZ&& o) { CResult_u32GraphSyncErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_u32GraphSyncErrorZ)); return *this; }
+	LDKCResult_u32GraphSyncErrorZ* operator &() { return &self; }
+	LDKCResult_u32GraphSyncErrorZ* operator ->() { return &self; }
+	const LDKCResult_u32GraphSyncErrorZ* operator &() const { return &self; }
+	const LDKCResult_u32GraphSyncErrorZ* operator ->() const { return &self; }
+};
 class CResult_UpdateAddHTLCDecodeErrorZ {
 private:
 	LDKCResult_UpdateAddHTLCDecodeErrorZ self;
@@ -6181,21 +6762,6 @@ public:
 	const LDKCResult_UpdateAddHTLCDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_UpdateAddHTLCDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_QueryShortChannelIdsDecodeErrorZ {
-private:
-	LDKCResult_QueryShortChannelIdsDecodeErrorZ self;
-public:
-	CResult_QueryShortChannelIdsDecodeErrorZ(const CResult_QueryShortChannelIdsDecodeErrorZ&) = delete;
-	CResult_QueryShortChannelIdsDecodeErrorZ(CResult_QueryShortChannelIdsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_QueryShortChannelIdsDecodeErrorZ)); }
-	CResult_QueryShortChannelIdsDecodeErrorZ(LDKCResult_QueryShortChannelIdsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ)); }
-	operator LDKCResult_QueryShortChannelIdsDecodeErrorZ() && { LDKCResult_QueryShortChannelIdsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ)); return res; }
-	~CResult_QueryShortChannelIdsDecodeErrorZ() { CResult_QueryShortChannelIdsDecodeErrorZ_free(self); }
-	CResult_QueryShortChannelIdsDecodeErrorZ& operator=(CResult_QueryShortChannelIdsDecodeErrorZ&& o) { CResult_QueryShortChannelIdsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_QueryShortChannelIdsDecodeErrorZ)); return *this; }
-	LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator ->() const { return &self; }
-};
 class CResult_CounterpartyChannelTransactionParametersDecodeErrorZ {
 private:
 	LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ self;
@@ -6286,6 +6852,21 @@ public:
 	const LDKCVec_C2Tuple_usizeTransactionZZ* operator &() const { return &self; }
 	const LDKCVec_C2Tuple_usizeTransactionZZ* operator ->() const { return &self; }
 };
+class CResult_QueryShortChannelIdsDecodeErrorZ {
+private:
+	LDKCResult_QueryShortChannelIdsDecodeErrorZ self;
+public:
+	CResult_QueryShortChannelIdsDecodeErrorZ(const CResult_QueryShortChannelIdsDecodeErrorZ&) = delete;
+	CResult_QueryShortChannelIdsDecodeErrorZ(CResult_QueryShortChannelIdsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_QueryShortChannelIdsDecodeErrorZ)); }
+	CResult_QueryShortChannelIdsDecodeErrorZ(LDKCResult_QueryShortChannelIdsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ)); }
+	operator LDKCResult_QueryShortChannelIdsDecodeErrorZ() && { LDKCResult_QueryShortChannelIdsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ)); return res; }
+	~CResult_QueryShortChannelIdsDecodeErrorZ() { CResult_QueryShortChannelIdsDecodeErrorZ_free(self); }
+	CResult_QueryShortChannelIdsDecodeErrorZ& operator=(CResult_QueryShortChannelIdsDecodeErrorZ&& o) { CResult_QueryShortChannelIdsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_QueryShortChannelIdsDecodeErrorZ)); return *this; }
+	LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator ->() const { return &self; }
+};
 class CVec_PhantomRouteHintsZ {
 private:
 	LDKCVec_PhantomRouteHintsZ self;
@@ -6586,21 +7167,6 @@ public:
 	const LDKCVec_C2Tuple_u32ScriptZZ* operator &() const { return &self; }
 	const LDKCVec_C2Tuple_u32ScriptZZ* operator ->() const { return &self; }
 };
-class CResult_NoneChannelMonitorUpdateErrZ {
-private:
-	LDKCResult_NoneChannelMonitorUpdateErrZ self;
-public:
-	CResult_NoneChannelMonitorUpdateErrZ(const CResult_NoneChannelMonitorUpdateErrZ&) = delete;
-	CResult_NoneChannelMonitorUpdateErrZ(CResult_NoneChannelMonitorUpdateErrZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneChannelMonitorUpdateErrZ)); }
-	CResult_NoneChannelMonitorUpdateErrZ(LDKCResult_NoneChannelMonitorUpdateErrZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ)); }
-	operator LDKCResult_NoneChannelMonitorUpdateErrZ() && { LDKCResult_NoneChannelMonitorUpdateErrZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ)); return res; }
-	~CResult_NoneChannelMonitorUpdateErrZ() { CResult_NoneChannelMonitorUpdateErrZ_free(self); }
-	CResult_NoneChannelMonitorUpdateErrZ& operator=(CResult_NoneChannelMonitorUpdateErrZ&& o) { CResult_NoneChannelMonitorUpdateErrZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneChannelMonitorUpdateErrZ)); return *this; }
-	LDKCResult_NoneChannelMonitorUpdateErrZ* operator &() { return &self; }
-	LDKCResult_NoneChannelMonitorUpdateErrZ* operator ->() { return &self; }
-	const LDKCResult_NoneChannelMonitorUpdateErrZ* operator &() const { return &self; }
-	const LDKCResult_NoneChannelMonitorUpdateErrZ* operator ->() const { return &self; }
-};
 class CResult_COption_ClosureReasonZDecodeErrorZ {
 private:
 	LDKCResult_COption_ClosureReasonZDecodeErrorZ self;
@@ -6631,6 +7197,21 @@ public:
 	const LDKCResult_PublicKeyErrorZ* operator &() const { return &self; }
 	const LDKCResult_PublicKeyErrorZ* operator ->() const { return &self; }
 };
+class CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ {
+private:
+	LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ self;
+public:
+	CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ(const CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ&) = delete;
+	CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ(CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ)); }
+	CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ(LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ)); }
+	operator LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ() && { LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ res = self; memset(&self, 0, sizeof(LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ)); return res; }
+	~CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ() { CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(self); }
+	CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ& operator=(CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ&& o) { CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ)); return *this; }
+	LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ* operator &() { return &self; }
+	LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ* operator ->() { return &self; }
+	const LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ* operator &() const { return &self; }
+	const LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ* operator ->() const { return &self; }
+};
 class C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ {
 private:
 	LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ self;
@@ -6766,6 +7347,21 @@ public:
 	const LDKCVec_UpdateFulfillHTLCZ* operator &() const { return &self; }
 	const LDKCVec_UpdateFulfillHTLCZ* operator ->() const { return &self; }
 };
+class CResult_BlindedRouteNoneZ {
+private:
+	LDKCResult_BlindedRouteNoneZ self;
+public:
+	CResult_BlindedRouteNoneZ(const CResult_BlindedRouteNoneZ&) = delete;
+	CResult_BlindedRouteNoneZ(CResult_BlindedRouteNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedRouteNoneZ)); }
+	CResult_BlindedRouteNoneZ(LDKCResult_BlindedRouteNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedRouteNoneZ)); }
+	operator LDKCResult_BlindedRouteNoneZ() && { LDKCResult_BlindedRouteNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedRouteNoneZ)); return res; }
+	~CResult_BlindedRouteNoneZ() { CResult_BlindedRouteNoneZ_free(self); }
+	CResult_BlindedRouteNoneZ& operator=(CResult_BlindedRouteNoneZ&& o) { CResult_BlindedRouteNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedRouteNoneZ)); return *this; }
+	LDKCResult_BlindedRouteNoneZ* operator &() { return &self; }
+	LDKCResult_BlindedRouteNoneZ* operator ->() { return &self; }
+	const LDKCResult_BlindedRouteNoneZ* operator &() const { return &self; }
+	const LDKCResult_BlindedRouteNoneZ* operator ->() const { return &self; }
+};
 class CResult_AnnouncementSignaturesDecodeErrorZ {
 private:
 	LDKCResult_AnnouncementSignaturesDecodeErrorZ self;
@@ -6886,6 +7482,21 @@ public:
 	const LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* operator ->() const { return &self; }
 };
+class COption_ScalarZ {
+private:
+	LDKCOption_ScalarZ self;
+public:
+	COption_ScalarZ(const COption_ScalarZ&) = delete;
+	COption_ScalarZ(COption_ScalarZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_ScalarZ)); }
+	COption_ScalarZ(LDKCOption_ScalarZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_ScalarZ)); }
+	operator LDKCOption_ScalarZ() && { LDKCOption_ScalarZ res = self; memset(&self, 0, sizeof(LDKCOption_ScalarZ)); return res; }
+	~COption_ScalarZ() { COption_ScalarZ_free(self); }
+	COption_ScalarZ& operator=(COption_ScalarZ&& o) { COption_ScalarZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_ScalarZ)); return *this; }
+	LDKCOption_ScalarZ* operator &() { return &self; }
+	LDKCOption_ScalarZ* operator ->() { return &self; }
+	const LDKCOption_ScalarZ* operator &() const { return &self; }
+	const LDKCOption_ScalarZ* operator ->() const { return &self; }
+};
 class CResult_SignedRawInvoiceParseErrorZ {
 private:
 	LDKCResult_SignedRawInvoiceParseErrorZ self;
@@ -6901,21 +7512,6 @@ public:
 	const LDKCResult_SignedRawInvoiceParseErrorZ* operator &() const { return &self; }
 	const LDKCResult_SignedRawInvoiceParseErrorZ* operator ->() const { return &self; }
 };
-class C2Tuple_u32ScriptZ {
-private:
-	LDKC2Tuple_u32ScriptZ self;
-public:
-	C2Tuple_u32ScriptZ(const C2Tuple_u32ScriptZ&) = delete;
-	C2Tuple_u32ScriptZ(C2Tuple_u32ScriptZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_u32ScriptZ)); }
-	C2Tuple_u32ScriptZ(LDKC2Tuple_u32ScriptZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_u32ScriptZ)); }
-	operator LDKC2Tuple_u32ScriptZ() && { LDKC2Tuple_u32ScriptZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_u32ScriptZ)); return res; }
-	~C2Tuple_u32ScriptZ() { C2Tuple_u32ScriptZ_free(self); }
-	C2Tuple_u32ScriptZ& operator=(C2Tuple_u32ScriptZ&& o) { C2Tuple_u32ScriptZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_u32ScriptZ)); return *this; }
-	LDKC2Tuple_u32ScriptZ* operator &() { return &self; }
-	LDKC2Tuple_u32ScriptZ* operator ->() { return &self; }
-	const LDKC2Tuple_u32ScriptZ* operator &() const { return &self; }
-	const LDKC2Tuple_u32ScriptZ* operator ->() const { return &self; }
-};
 class CResult_RouteDecodeErrorZ {
 private:
 	LDKCResult_RouteDecodeErrorZ self;
@@ -6991,20 +7587,20 @@ public:
 	const LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator ->() const { return &self; }
 };
-class CVec_C2Tuple_OutPointCVec_MonitorEventZZZ {
+class C2Tuple_u32ScriptZ {
 private:
-	LDKCVec_C2Tuple_OutPointCVec_MonitorEventZZZ self;
+	LDKC2Tuple_u32ScriptZ self;
 public:
-	CVec_C2Tuple_OutPointCVec_MonitorEventZZZ(const CVec_C2Tuple_OutPointCVec_MonitorEventZZZ&) = delete;
-	CVec_C2Tuple_OutPointCVec_MonitorEventZZZ(CVec_C2Tuple_OutPointCVec_MonitorEventZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_OutPointCVec_MonitorEventZZZ)); }
-	CVec_C2Tuple_OutPointCVec_MonitorEventZZZ(LDKCVec_C2Tuple_OutPointCVec_MonitorEventZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_OutPointCVec_MonitorEventZZZ)); }
-	operator LDKCVec_C2Tuple_OutPointCVec_MonitorEventZZZ() && { LDKCVec_C2Tuple_OutPointCVec_MonitorEventZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_OutPointCVec_MonitorEventZZZ)); return res; }
-	~CVec_C2Tuple_OutPointCVec_MonitorEventZZZ() { CVec_C2Tuple_OutPointCVec_MonitorEventZZZ_free(self); }
-	CVec_C2Tuple_OutPointCVec_MonitorEventZZZ& operator=(CVec_C2Tuple_OutPointCVec_MonitorEventZZZ&& o) { CVec_C2Tuple_OutPointCVec_MonitorEventZZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_OutPointCVec_MonitorEventZZZ)); return *this; }
-	LDKCVec_C2Tuple_OutPointCVec_MonitorEventZZZ* operator &() { return &self; }
-	LDKCVec_C2Tuple_OutPointCVec_MonitorEventZZZ* operator ->() { return &self; }
-	const LDKCVec_C2Tuple_OutPointCVec_MonitorEventZZZ* operator &() const { return &self; }
-	const LDKCVec_C2Tuple_OutPointCVec_MonitorEventZZZ* operator ->() const { return &self; }
+	C2Tuple_u32ScriptZ(const C2Tuple_u32ScriptZ&) = delete;
+	C2Tuple_u32ScriptZ(C2Tuple_u32ScriptZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_u32ScriptZ)); }
+	C2Tuple_u32ScriptZ(LDKC2Tuple_u32ScriptZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_u32ScriptZ)); }
+	operator LDKC2Tuple_u32ScriptZ() && { LDKC2Tuple_u32ScriptZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_u32ScriptZ)); return res; }
+	~C2Tuple_u32ScriptZ() { C2Tuple_u32ScriptZ_free(self); }
+	C2Tuple_u32ScriptZ& operator=(C2Tuple_u32ScriptZ&& o) { C2Tuple_u32ScriptZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_u32ScriptZ)); return *this; }
+	LDKC2Tuple_u32ScriptZ* operator &() { return &self; }
+	LDKC2Tuple_u32ScriptZ* operator ->() { return &self; }
+	const LDKC2Tuple_u32ScriptZ* operator &() const { return &self; }
+	const LDKC2Tuple_u32ScriptZ* operator ->() const { return &self; }
 };
 class CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ {
 private:
@@ -7063,6 +7659,10 @@ inline LDK::CVec_MessageSendEventZ MessageSendEventsProvider::get_and_clear_pend
 	LDK::CVec_MessageSendEventZ ret = (self.get_and_clear_pending_msg_events)(self.this_arg);
 	return ret;
 }
+inline LDK::OnionMessage OnionMessageProvider::next_onion_message_for_peer(struct LDKPublicKey peer_node_id) {
+	LDK::OnionMessage ret = (self.next_onion_message_for_peer)(self.this_arg, peer_node_id);
+	return ret;
+}
 inline void EventsProvider::process_pending_events(struct LDKEventHandler handler) {
 	(self.process_pending_events)(self.this_arg, handler);
 }
@@ -7095,24 +7695,23 @@ inline LDK::CVec_TxidZ Confirm::get_relevant_txids() {
 	LDK::CVec_TxidZ ret = (self.get_relevant_txids)(self.this_arg);
 	return ret;
 }
-inline LDK::CResult_NoneChannelMonitorUpdateErrZ Watch::watch_channel(struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor) {
-	LDK::CResult_NoneChannelMonitorUpdateErrZ ret = (self.watch_channel)(self.this_arg, funding_txo, monitor);
+inline LDK::ChannelMonitorUpdateStatus Watch::watch_channel(struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor) {
+	LDK::ChannelMonitorUpdateStatus ret = (self.watch_channel)(self.this_arg, funding_txo, monitor);
 	return ret;
 }
-inline LDK::CResult_NoneChannelMonitorUpdateErrZ Watch::update_channel(struct LDKOutPoint funding_txo, struct LDKChannelMonitorUpdate update) {
-	LDK::CResult_NoneChannelMonitorUpdateErrZ ret = (self.update_channel)(self.this_arg, funding_txo, update);
+inline LDK::ChannelMonitorUpdateStatus Watch::update_channel(struct LDKOutPoint funding_txo, struct LDKChannelMonitorUpdate update) {
+	LDK::ChannelMonitorUpdateStatus ret = (self.update_channel)(self.this_arg, funding_txo, update);
 	return ret;
 }
-inline LDK::CVec_C2Tuple_OutPointCVec_MonitorEventZZZ Watch::release_pending_monitor_events() {
-	LDK::CVec_C2Tuple_OutPointCVec_MonitorEventZZZ ret = (self.release_pending_monitor_events)(self.this_arg);
+inline LDK::CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ Watch::release_pending_monitor_events() {
+	LDK::CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ ret = (self.release_pending_monitor_events)(self.this_arg);
 	return ret;
 }
 inline void Filter::register_tx(const uint8_t (*txid)[32], struct LDKu8slice script_pubkey) {
 	(self.register_tx)(self.this_arg, txid, script_pubkey);
 }
-inline LDK::COption_C2Tuple_usizeTransactionZZ Filter::register_output(struct LDKWatchedOutput output) {
-	LDK::COption_C2Tuple_usizeTransactionZZ ret = (self.register_output)(self.this_arg, output);
-	return ret;
+inline void Filter::register_output(struct LDKWatchedOutput output) {
+	(self.register_output)(self.this_arg, output);
 }
 inline uint64_t Score::channel_penalty_msat(uint64_t short_channel_id, const struct LDKNodeId *NONNULL_PTR source, const struct LDKNodeId *NONNULL_PTR target, struct LDKChannelUsage usage) {
 	uint64_t ret = (self.channel_penalty_msat)(self.this_arg, short_channel_id, source, target, usage);
@@ -7124,10 +7723,20 @@ inline void Score::payment_path_failed(struct LDKCVec_RouteHopZ path, uint64_t s
 inline void Score::payment_path_successful(struct LDKCVec_RouteHopZ path) {
 	(self.payment_path_successful)(self.this_arg, path);
 }
+inline void Score::probe_failed(struct LDKCVec_RouteHopZ path, uint64_t short_channel_id) {
+	(self.probe_failed)(self.this_arg, path, short_channel_id);
+}
+inline void Score::probe_successful(struct LDKCVec_RouteHopZ path) {
+	(self.probe_successful)(self.this_arg, path);
+}
 inline LDK::Score LockableScore::lock() {
 	LDK::Score ret = (self.lock)(self.this_arg);
 	return ret;
 }
+inline uint64_t CustomOnionMessageContents::tlv_type() {
+	uint64_t ret = (self.tlv_type)(self.this_arg);
+	return ret;
+}
 inline LDKPublicKey BaseSign::get_per_commitment_point(uint64_t idx) {
 	LDKPublicKey ret = (self.get_per_commitment_point)(self.this_arg, idx);
 	return ret;
@@ -7172,6 +7781,10 @@ inline LDK::CResult_SignatureNoneZ BaseSign::sign_closing_transaction(const stru
 	LDK::CResult_SignatureNoneZ ret = (self.sign_closing_transaction)(self.this_arg, closing_tx);
 	return ret;
 }
+inline LDK::CResult_SignatureNoneZ BaseSign::sign_holder_anchor_input(struct LDKTransaction anchor_tx, uintptr_t input) {
+	LDK::CResult_SignatureNoneZ ret = (self.sign_holder_anchor_input)(self.this_arg, anchor_tx, input);
+	return ret;
+}
 inline LDK::CResult_C2Tuple_SignatureSignatureZNoneZ BaseSign::sign_channel_announcement(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg) {
 	LDK::CResult_C2Tuple_SignatureSignatureZNoneZ ret = (self.sign_channel_announcement)(self.this_arg, msg);
 	return ret;
@@ -7183,6 +7796,14 @@ inline LDK::CResult_SecretKeyNoneZ KeysInterface::get_node_secret(enum LDKRecipi
 	LDK::CResult_SecretKeyNoneZ ret = (self.get_node_secret)(self.this_arg, recipient);
 	return ret;
 }
+inline LDK::CResult_PublicKeyNoneZ KeysInterface::get_node_id(enum LDKRecipient recipient) {
+	LDK::CResult_PublicKeyNoneZ ret = (self.get_node_id)(self.this_arg, recipient);
+	return ret;
+}
+inline LDK::CResult_SharedSecretNoneZ KeysInterface::ecdh(enum LDKRecipient recipient, struct LDKPublicKey other_key, struct LDKCOption_ScalarZ tweak) {
+	LDK::CResult_SharedSecretNoneZ ret = (self.ecdh)(self.this_arg, recipient, other_key, tweak);
+	return ret;
+}
 inline LDK::CVec_u8Z KeysInterface::get_destination_script() {
 	LDK::CVec_u8Z ret = (self.get_destination_script)(self.this_arg);
 	return ret;
@@ -7246,10 +7867,22 @@ inline LDK::CResult_NonePaymentSendFailureZ Payer::retry_payment(const struct LD
 inline void Payer::abandon_payment(struct LDKThirtyTwoBytes payment_id) {
 	(self.abandon_payment)(self.this_arg, payment_id);
 }
-inline LDK::CResult_RouteLightningErrorZ Router::find_route(struct LDKPublicKey payer, const struct LDKRouteParameters *NONNULL_PTR route_params, const uint8_t (*payment_hash)[32], struct LDKCVec_ChannelDetailsZ *first_hops, const struct LDKScore *NONNULL_PTR scorer) {
-	LDK::CResult_RouteLightningErrorZ ret = (self.find_route)(self.this_arg, payer, route_params, payment_hash, first_hops, scorer);
+inline LDK::CResult_RouteLightningErrorZ Router::find_route(struct LDKPublicKey payer, const struct LDKRouteParameters *NONNULL_PTR route_params, const uint8_t (*payment_hash)[32], struct LDKCVec_ChannelDetailsZ *first_hops, struct LDKInFlightHtlcs inflight_htlcs) {
+	LDK::CResult_RouteLightningErrorZ ret = (self.find_route)(self.this_arg, payer, route_params, payment_hash, first_hops, inflight_htlcs);
 	return ret;
 }
+inline void Router::notify_payment_path_failed(struct LDKCVec_RouteHopZ path, uint64_t short_channel_id) {
+	(self.notify_payment_path_failed)(self.this_arg, path, short_channel_id);
+}
+inline void Router::notify_payment_path_successful(struct LDKCVec_RouteHopZ path) {
+	(self.notify_payment_path_successful)(self.this_arg, path);
+}
+inline void Router::notify_payment_probe_successful(struct LDKCVec_RouteHopZ path) {
+	(self.notify_payment_probe_successful)(self.this_arg, path);
+}
+inline void Router::notify_payment_probe_failed(struct LDKCVec_RouteHopZ path, uint64_t short_channel_id) {
+	(self.notify_payment_probe_failed)(self.this_arg, path, short_channel_id);
+}
 inline LDK::CResult_NoneLightningErrorZ CustomMessageHandler::handle_custom_message(struct LDKType msg, struct LDKPublicKey sender_node_id) {
 	LDK::CResult_NoneLightningErrorZ ret = (self.handle_custom_message)(self.this_arg, msg, sender_node_id);
 	return ret;
@@ -7273,6 +7906,13 @@ inline uint64_t SocketDescriptor::hash() {
 	uint64_t ret = (self.hash)(self.this_arg);
 	return ret;
 }
+inline void CustomOnionMessageHandler::handle_custom_message(struct LDKCustomOnionMessageContents msg) {
+	(self.handle_custom_message)(self.this_arg, msg);
+}
+inline LDK::CResult_COption_CustomOnionMessageContentsZDecodeErrorZ CustomOnionMessageHandler::read_custom_message(uint64_t message_type, struct LDKu8slice buffer) {
+	LDK::CResult_COption_CustomOnionMessageContentsZDecodeErrorZ ret = (self.read_custom_message)(self.this_arg, message_type, buffer);
+	return ret;
+}
 inline LDK::CResult_NoneErrorZ Persister::persist_manager(const struct LDKChannelManager *NONNULL_PTR channel_manager) {
 	LDK::CResult_NoneErrorZ ret = (self.persist_manager)(self.this_arg, channel_manager);
 	return ret;
@@ -7281,7 +7921,7 @@ inline LDK::CResult_NoneErrorZ Persister::persist_graph(const struct LDKNetworkG
 	LDK::CResult_NoneErrorZ ret = (self.persist_graph)(self.this_arg, network_graph);
 	return ret;
 }
-inline LDK::CResult_NoneErrorZ Persister::persist_scorer(const struct LDKMultiThreadedLockableScore *NONNULL_PTR scorer) {
+inline LDK::CResult_NoneErrorZ Persister::persist_scorer(const struct LDKWriteableScore *NONNULL_PTR scorer) {
 	LDK::CResult_NoneErrorZ ret = (self.persist_scorer)(self.this_arg, scorer);
 	return ret;
 }
@@ -7333,8 +7973,9 @@ inline void ChannelMessageHandler::handle_announcement_signatures(struct LDKPubl
 inline void ChannelMessageHandler::peer_disconnected(struct LDKPublicKey their_node_id, bool no_connection_possible) {
 	(self.peer_disconnected)(self.this_arg, their_node_id, no_connection_possible);
 }
-inline void ChannelMessageHandler::peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg) {
-	(self.peer_connected)(self.this_arg, their_node_id, msg);
+inline LDK::CResult_NoneNoneZ ChannelMessageHandler::peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg) {
+	LDK::CResult_NoneNoneZ ret = (self.peer_connected)(self.this_arg, their_node_id, msg);
+	return ret;
 }
 inline void ChannelMessageHandler::handle_channel_reestablish(struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg) {
 	(self.handle_channel_reestablish)(self.this_arg, their_node_id, msg);
@@ -7345,6 +7986,14 @@ inline void ChannelMessageHandler::handle_channel_update(struct LDKPublicKey the
 inline void ChannelMessageHandler::handle_error(struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg) {
 	(self.handle_error)(self.this_arg, their_node_id, msg);
 }
+inline LDK::NodeFeatures ChannelMessageHandler::provided_node_features() {
+	LDK::NodeFeatures ret = (self.provided_node_features)(self.this_arg);
+	return ret;
+}
+inline LDK::InitFeatures ChannelMessageHandler::provided_init_features(struct LDKPublicKey their_node_id) {
+	LDK::InitFeatures ret = (self.provided_init_features)(self.this_arg, their_node_id);
+	return ret;
+}
 inline LDK::CResult_boolLightningErrorZ RoutingMessageHandler::handle_node_announcement(const struct LDKNodeAnnouncement *NONNULL_PTR msg) {
 	LDK::CResult_boolLightningErrorZ ret = (self.handle_node_announcement)(self.this_arg, msg);
 	return ret;
@@ -7357,16 +8006,17 @@ inline LDK::CResult_boolLightningErrorZ RoutingMessageHandler::handle_channel_up
 	LDK::CResult_boolLightningErrorZ ret = (self.handle_channel_update)(self.this_arg, msg);
 	return ret;
 }
-inline LDK::CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ RoutingMessageHandler::get_next_channel_announcements(uint64_t starting_point, uint8_t batch_amount) {
-	LDK::CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ ret = (self.get_next_channel_announcements)(self.this_arg, starting_point, batch_amount);
+inline LDK::COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ RoutingMessageHandler::get_next_channel_announcement(uint64_t starting_point) {
+	LDK::COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ ret = (self.get_next_channel_announcement)(self.this_arg, starting_point);
 	return ret;
 }
-inline LDK::CVec_NodeAnnouncementZ RoutingMessageHandler::get_next_node_announcements(struct LDKPublicKey starting_point, uint8_t batch_amount) {
-	LDK::CVec_NodeAnnouncementZ ret = (self.get_next_node_announcements)(self.this_arg, starting_point, batch_amount);
+inline LDK::NodeAnnouncement RoutingMessageHandler::get_next_node_announcement(struct LDKPublicKey starting_point) {
+	LDK::NodeAnnouncement ret = (self.get_next_node_announcement)(self.this_arg, starting_point);
 	return ret;
 }
-inline void RoutingMessageHandler::peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init) {
-	(self.peer_connected)(self.this_arg, their_node_id, init);
+inline LDK::CResult_NoneNoneZ RoutingMessageHandler::peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init) {
+	LDK::CResult_NoneNoneZ ret = (self.peer_connected)(self.this_arg, their_node_id, init);
+	return ret;
 }
 inline LDK::CResult_NoneLightningErrorZ RoutingMessageHandler::handle_reply_channel_range(struct LDKPublicKey their_node_id, struct LDKReplyChannelRange msg) {
 	LDK::CResult_NoneLightningErrorZ ret = (self.handle_reply_channel_range)(self.this_arg, their_node_id, msg);
@@ -7384,15 +8034,44 @@ inline LDK::CResult_NoneLightningErrorZ RoutingMessageHandler::handle_query_shor
 	LDK::CResult_NoneLightningErrorZ ret = (self.handle_query_short_channel_ids)(self.this_arg, their_node_id, msg);
 	return ret;
 }
+inline LDK::NodeFeatures RoutingMessageHandler::provided_node_features() {
+	LDK::NodeFeatures ret = (self.provided_node_features)(self.this_arg);
+	return ret;
+}
+inline LDK::InitFeatures RoutingMessageHandler::provided_init_features(struct LDKPublicKey their_node_id) {
+	LDK::InitFeatures ret = (self.provided_init_features)(self.this_arg, their_node_id);
+	return ret;
+}
+inline void OnionMessageHandler::handle_onion_message(struct LDKPublicKey peer_node_id, const struct LDKOnionMessage *NONNULL_PTR msg) {
+	(self.handle_onion_message)(self.this_arg, peer_node_id, msg);
+}
+inline LDK::CResult_NoneNoneZ OnionMessageHandler::peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init) {
+	LDK::CResult_NoneNoneZ ret = (self.peer_connected)(self.this_arg, their_node_id, init);
+	return ret;
+}
+inline void OnionMessageHandler::peer_disconnected(struct LDKPublicKey their_node_id, bool no_connection_possible) {
+	(self.peer_disconnected)(self.this_arg, their_node_id, no_connection_possible);
+}
+inline LDK::NodeFeatures OnionMessageHandler::provided_node_features() {
+	LDK::NodeFeatures ret = (self.provided_node_features)(self.this_arg);
+	return ret;
+}
+inline LDK::InitFeatures OnionMessageHandler::provided_init_features(struct LDKPublicKey their_node_id) {
+	LDK::InitFeatures ret = (self.provided_init_features)(self.this_arg, their_node_id);
+	return ret;
+}
 inline void Logger::log(const struct LDKRecord *NONNULL_PTR record) {
 	(self.log)(self.this_arg, record);
 }
-inline LDK::CResult_NoneChannelMonitorUpdateErrZ Persist::persist_new_channel(struct LDKOutPoint channel_id, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id) {
-	LDK::CResult_NoneChannelMonitorUpdateErrZ ret = (self.persist_new_channel)(self.this_arg, channel_id, data, update_id);
+inline void FutureCallback::call() {
+	(self.call)(self.this_arg);
+}
+inline LDK::ChannelMonitorUpdateStatus Persist::persist_new_channel(struct LDKOutPoint channel_id, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id) {
+	LDK::ChannelMonitorUpdateStatus ret = (self.persist_new_channel)(self.this_arg, channel_id, data, update_id);
 	return ret;
 }
-inline LDK::CResult_NoneChannelMonitorUpdateErrZ Persist::update_persisted_channel(struct LDKOutPoint channel_id, const struct LDKChannelMonitorUpdate *NONNULL_PTR update, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id) {
-	LDK::CResult_NoneChannelMonitorUpdateErrZ ret = (self.update_persisted_channel)(self.this_arg, channel_id, update, data, update_id);
+inline LDK::ChannelMonitorUpdateStatus Persist::update_persisted_channel(struct LDKOutPoint channel_id, const struct LDKChannelMonitorUpdate *NONNULL_PTR update, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id) {
+	LDK::ChannelMonitorUpdateStatus ret = (self.update_persisted_channel)(self.this_arg, channel_id, update, data, update_id);
 	return ret;
 }
 }