X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning-c-bindings%2Finclude%2Flightningpp.hpp;h=c9e30a33a1261ed195b9831f532a254dd27a4ffa;hb=11b997c3a0452ea1da5b7b352e7887798105db29;hp=1b383c094ef84d04f9c2694795496e86f793b4b0;hpb=4a9bca517dc3124d5f960677621358135266dbba;p=ldk-c-bindings

diff --git a/lightning-c-bindings/include/lightningpp.hpp b/lightning-c-bindings/include/lightningpp.hpp
index 1b383c0..c9e30a3 100644
--- a/lightning-c-bindings/include/lightningpp.hpp
+++ b/lightning-c-bindings/include/lightningpp.hpp
@@ -2,6 +2,10 @@
 namespace LDK {
 // Forward declarations
 class Str;
+class Retry;
+class RetryableSendFailure;
+class PaymentSendFailure;
+class HTLCClaim;
 class CounterpartyCommitmentSecrets;
 class TxCreationKeys;
 class ChannelPublicKeys;
@@ -17,8 +21,14 @@ class CommitmentTransaction;
 class TrustedCommitmentTransaction;
 class ShutdownScript;
 class InvalidShutdownScript;
+class BlindedPath;
+class BlindedHop;
 class BackgroundProcessor;
 class GossipSync;
+class DefaultRouter;
+class Router;
+class ScorerAccountingForInFlightHtlcs;
+class InFlightHtlcs;
 class RouteHop;
 class Route;
 class RouteParameters;
@@ -29,24 +39,27 @@ class BroadcasterInterface;
 class ConfirmationTarget;
 class FeeEstimator;
 class PaymentPurpose;
+class PathFailure;
 class ClosureReason;
+class HTLCDestination;
 class Event;
 class MessageSendEvent;
 class MessageSendEventsProvider;
+class OnionMessageProvider;
 class EventsProvider;
 class EventHandler;
 class BestBlock;
-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;
@@ -55,7 +68,13 @@ class InitFeatures;
 class NodeFeatures;
 class ChannelFeatures;
 class InvoiceFeatures;
+class OfferFeatures;
+class InvoiceRequestFeatures;
+class Bolt12InvoiceFeatures;
+class BlindedHopFeatures;
 class ChannelTypeFeatures;
+class OnionMessageContents;
+class CustomOnionMessageContents;
 class NodeId;
 class NetworkGraph;
 class ReadOnlyNetworkGraph;
@@ -72,20 +91,24 @@ class NodeInfo;
 class DelayedPaymentOutputDescriptor;
 class StaticPaymentOutputDescriptor;
 class SpendableOutputDescriptor;
-class BaseSign;
-class Sign;
+class ChannelSigner;
+class EcdsaChannelSigner;
+class WriteableEcdsaChannelSigner;
 class Recipient;
-class KeysInterface;
+class EntropySource;
+class NodeSigner;
+class SignerProvider;
 class InMemorySigner;
 class KeysManager;
 class PhantomKeysManager;
 class FilesystemPersister;
+class FailureCode;
 class ChannelManager;
 class ChainParameters;
 class CounterpartyForwardingInfo;
 class ChannelCounterparty;
 class ChannelDetails;
-class PaymentSendFailure;
+class RecentPaymentDetails;
 class PhantomRouteHints;
 class ChannelManagerReadArgs;
 class ChannelHandshakeConfig;
@@ -94,14 +117,33 @@ class ChannelConfig;
 class UserConfig;
 class APIError;
 class BigSize;
+class Hostname;
+class PrintableString;
 class OutPoint;
 class CustomMessageReader;
 class Type;
-class InvoicePayer;
-class Payer;
-class Router;
-class Retry;
 class PaymentError;
+class ChannelMonitorUpdate;
+class MonitorEvent;
+class HTLCUpdate;
+class Balance;
+class ChannelMonitor;
+class ExpandedKey;
+class CustomMessageHandler;
+class IgnoringMessageHandler;
+class ErroringMessageHandler;
+class MessageHandler;
+class SocketDescriptor;
+class PeerHandleError;
+class PeerManager;
+class UtxoLookupError;
+class UtxoResult;
+class UtxoLookup;
+class UtxoFuture;
+class OnionMessenger;
+class Destination;
+class SendError;
+class CustomOnionMessageHandler;
 class ParseError;
 class ParseOrSemanticError;
 class Invoice;
@@ -115,26 +157,13 @@ class Sha256;
 class Description;
 class PayeePubKey;
 class ExpiryTime;
-class MinFinalCltvExpiry;
+class MinFinalCltvExpiryDelta;
 class Fallback;
 class InvoiceSignature;
 class PrivateRoute;
 class CreationError;
 class SemanticError;
 class SignOrCreationError;
-class ChannelMonitorUpdate;
-class MonitorEvent;
-class HTLCUpdate;
-class Balance;
-class ChannelMonitor;
-class ExpandedKey;
-class CustomMessageHandler;
-class IgnoringMessageHandler;
-class ErroringMessageHandler;
-class MessageHandler;
-class SocketDescriptor;
-class PeerHandleError;
-class PeerManager;
 class RapidGossipSync;
 class Persister;
 class DecodeError;
@@ -152,6 +181,7 @@ class Shutdown;
 class ClosingSignedFeeRange;
 class ClosingSigned;
 class UpdateAddHTLC;
+class OnionMessage;
 class UpdateFulfillHTLC;
 class UpdateFailHTLC;
 class UpdateFailMalformedHTLC;
@@ -162,6 +192,7 @@ class DataLossProtect;
 class ChannelReestablish;
 class AnnouncementSignatures;
 class NetAddress;
+class UnsignedGossipMessage;
 class UnsignedNodeAnnouncement;
 class NodeAnnouncement;
 class UnsignedChannelAnnouncement;
@@ -178,225 +209,253 @@ 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;
 class ChainMonitor;
-class CVec_SpendableOutputDescriptorZ;
 class CResult_LockedChannelMonitorNoneZ;
 class CResult_PhantomRouteHintsDecodeErrorZ;
-class COption_C2Tuple_u64u64ZZ;
 class CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ;
 class CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ;
-class CResult_HTLCUpdateDecodeErrorZ;
-class C2Tuple_SignatureCVec_SignatureZZ;
 class CVec_C2Tuple_u32TxOutZZ;
-class CResult_ChannelInfoDecodeErrorZ;
 class CResult_FundingCreatedDecodeErrorZ;
-class CResult_ChannelAnnouncementDecodeErrorZ;
-class CVec_OutPointZ;
-class CResult_PositiveTimestampCreationErrorZ;
+class CResult_ChannelInfoDecodeErrorZ;
+class CResult_NoneSendErrorZ;
 class CResult_CVec_u8ZPeerHandleErrorZ;
-class CResult_InvoiceFeaturesDecodeErrorZ;
+class CResult_GossipTimestampFilterDecodeErrorZ;
 class COption_NetworkUpdateZ;
 class COption_u64Z;
-class CResult_TxOutAccessErrorZ;
-class CResult_TrustedClosingTransactionNoneZ;
 class CResult_PaymentPreimageAPIErrorZ;
-class CResult_ChannelMonitorUpdateDecodeErrorZ;
 class CResult_RouteHintDecodeErrorZ;
-class C2Tuple_PublicKeyTypeZ;
-class CResult_NetAddressDecodeErrorZ;
-class CResult_ChannelReestablishDecodeErrorZ;
-class CResult_CommitmentSignedDecodeErrorZ;
+class COption_FilterZ;
+class COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ;
+class CResult_COption_APIErrorZDecodeErrorZ;
 class CVec_UpdateAddHTLCZ;
-class CResult_UnsignedNodeAnnouncementDecodeErrorZ;
+class CResult_CommitmentSignedDecodeErrorZ;
 class COption_u32Z;
-class CResult_InitFeaturesDecodeErrorZ;
 class CResult_StaticPaymentOutputDescriptorDecodeErrorZ;
-class CResult_PaymentIdPaymentSendFailureZ;
-class CResult_ReplyChannelRangeDecodeErrorZ;
+class CVec_C2Tuple_TxidBlockHashZZ;
 class CResult_CommitmentTransactionDecodeErrorZ;
-class COption_C2Tuple_usizeTransactionZZ;
 class CResult_TransactionNoneZ;
 class CResult_ClosingSignedFeeRangeDecodeErrorZ;
-class CResult_PingDecodeErrorZ;
-class CResult_GossipTimestampFilterDecodeErrorZ;
-class CResult_InvoiceSignOrCreationErrorZ;
-class COption_FilterZ;
-class CVec_TransactionOutputsZ;
 class CResult_ErrorMessageDecodeErrorZ;
 class CResult_OpenChannelDecodeErrorZ;
-class CVec_CVec_u8ZZ;
-class CResult_SecretKeyErrorZ;
-class CResult_ShutdownScriptDecodeErrorZ;
-class CResult_ProbabilisticScorerDecodeErrorZ;
+class COption_APIErrorZ;
 class CResult_QueryChannelRangeDecodeErrorZ;
-class CResult_TxCreationKeysDecodeErrorZ;
-class C2Tuple_usizeTransactionZ;
-class CResult_ChannelFeaturesDecodeErrorZ;
-class CVec_ChannelMonitorZ;
 class CVec_TransactionZ;
+class C2Tuple_TxidBlockHashZ;
+class CResult_ChannelFeaturesDecodeErrorZ;
 class CResult_ChannelReadyDecodeErrorZ;
-class CResult_RouteHopDecodeErrorZ;
 class CResult_UpdateFeeDecodeErrorZ;
-class CResult_NodeAnnouncementDecodeErrorZ;
-class CVec_BalanceZ;
 class CResult_HTLCOutputInCommitmentDecodeErrorZ;
 class CResult_boolLightningErrorZ;
-class CResult_TxCreationKeysErrorZ;
 class CResult_NodeIdDecodeErrorZ;
+class COption_HTLCDestinationZ;
 class C2Tuple_BlockHashChannelMonitorZ;
 class CResult_ShutdownScriptInvalidShutdownScriptZ;
 class CResult_NodeAnnouncementInfoDecodeErrorZ;
 class CResult_COption_NetworkUpdateZDecodeErrorZ;
-class CResult_RecoverableSignatureNoneZ;
-class C3Tuple_RawInvoice_u832InvoiceSignatureZ;
+class CResult_NoneRetryableSendFailureZ;
 class CVec_UpdateFailMalformedHTLCZ;
+class CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ;
+class CVec_C2Tuple_PublicKeyCOption_NetAddressZZZ;
+class CVec_RouteHopZ;
+class COption_CustomOnionMessageContentsZ;
+class CVec_C2Tuple_BlockHashChannelMonitorZZ;
+class CVec_ThirtyTwoBytesZ;
+class CResult_ClosingSignedDecodeErrorZ;
+class CResult_NonePaymentErrorZ;
+class CVec_CResult_NoneAPIErrorZZ;
+class CResult_CounterpartyCommitmentSecretsDecodeErrorZ;
+class CVec_RecentPaymentDetailsZ;
+class CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ;
+class CVec_RouteHintHopZ;
+class CResult_PaymentParametersDecodeErrorZ;
+class CVec_U5Z;
+class COption_UtxoLookupZ;
+class CResult_PongDecodeErrorZ;
+class CResult_UnsignedChannelAnnouncementDecodeErrorZ;
+class C2Tuple_OutPointCVec_MonitorUpdateIdZZ;
+class CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ;
+class C2Tuple_BlockHashChannelManagerZ;
+class CResult_ChannelTransactionParametersDecodeErrorZ;
+class CResult_WriteableEcdsaChannelSignerDecodeErrorZ;
+class CResult_DelayedPaymentOutputDescriptorDecodeErrorZ;
+class C2Tuple_PaymentHashPaymentIdZ;
+class CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ;
+class CResult_NoneErrorZ;
+class CResult_InFlightHtlcsDecodeErrorZ;
+class CResult_COption_HTLCDestinationZDecodeErrorZ;
+class CResult_SiPrefixParseErrorZ;
+class CResult_BlindedHopDecodeErrorZ;
+class CResult_TrustedCommitmentTransactionNoneZ;
+class CResult_FixedPenaltyScorerDecodeErrorZ;
+class CResult_NoneLightningErrorZ;
+class CResult_PaymentHashRetryableSendFailureZ;
+class C2Tuple_PublicKeyCOption_NetAddressZZ;
+class CResult_COption_EventZDecodeErrorZ;
+class CResult_CVec_SignatureZNoneZ;
+class COption_CVec_NetAddressZZ;
+class CResult_NonePeerHandleErrorZ;
+class CResult__u832APIErrorZ;
+class CResult_PaymentIdPaymentErrorZ;
+class CResult_COption_MonitorEventZDecodeErrorZ;
+class CResult_RoutingFeesDecodeErrorZ;
+class CResult_PayeePubKeyErrorZ;
+class CResult_DescriptionCreationErrorZ;
+class CResult_QueryShortChannelIdsDecodeErrorZ;
+class CResult_InvoiceSemanticErrorZ;
+class CResult_UpdateAddHTLCDecodeErrorZ;
+class COption_MonitorEventZ;
+class COption_TypeZ;
+class CResult_COption_TypeZDecodeErrorZ;
+class CResult_COption_PathFailureZDecodeErrorZ;
+class CResult_UpdateFailHTLCDecodeErrorZ;
+class CResult_InvoiceParseOrSemanticErrorZ;
+class CResult_RevokeAndACKDecodeErrorZ;
+class CResult_SpendableOutputDescriptorDecodeErrorZ;
+class CResult_UnsignedChannelUpdateDecodeErrorZ;
+class CVec_EventZ;
+class CResult_NoneSemanticErrorZ;
+class CVec_C2Tuple_u32ScriptZZ;
+class CResult_COption_ClosureReasonZDecodeErrorZ;
+class CResult_PaymentHashPaymentSendFailureZ;
+class C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ;
+class CResult_RouteParametersDecodeErrorZ;
+class CResult_PrivateRouteCreationErrorZ;
+class CResult_NodeAliasDecodeErrorZ;
+class CVec_UpdateFulfillHTLCZ;
+class CResult_AnnouncementSignaturesDecodeErrorZ;
+class CResult_UpdateFulfillHTLCDecodeErrorZ;
+class CResult_NodeFeaturesDecodeErrorZ;
+class CResult_InMemorySignerDecodeErrorZ;
+class CResult_ReplyShortChannelIdsEndDecodeErrorZ;
+class COption_PathFailureZ;
+class COption_ScalarZ;
+class CResult_ChannelUpdateInfoDecodeErrorZ;
+class CResult_BuiltCommitmentTransactionDecodeErrorZ;
+class CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ;
+class CVec_TxOutZ;
+class CVec_UpdateFailHTLCZ;
+class CVec_SpendableOutputDescriptorZ;
+class COption_C2Tuple_u64u64ZZ;
+class CResult_ChannelAnnouncementDecodeErrorZ;
+class CResult_HTLCUpdateDecodeErrorZ;
+class C2Tuple_SignatureCVec_SignatureZZ;
+class CVec_OutPointZ;
+class COption_WriteableScoreZ;
+class CResult_PositiveTimestampCreationErrorZ;
+class C2Tuple__u168_u168Z;
+class CResult_InvoiceFeaturesDecodeErrorZ;
+class CResult_ChannelMonitorUpdateDecodeErrorZ;
+class CResult_ReplyChannelRangeDecodeErrorZ;
+class CResult_InvoiceSignOrCreationErrorZ;
+class CResult_TrustedClosingTransactionNoneZ;
+class CResult_NetAddressDecodeErrorZ;
+class C2Tuple_PublicKeyTypeZ;
+class CResult_ChannelReestablishDecodeErrorZ;
+class CResult_OnionMessageDecodeErrorZ;
+class CResult_UnsignedNodeAnnouncementDecodeErrorZ;
+class CResult_InitFeaturesDecodeErrorZ;
+class CResult_PublicKeyNoneZ;
+class CResult_PingDecodeErrorZ;
+class CResult_BlindedHopFeaturesDecodeErrorZ;
+class CVec_TransactionOutputsZ;
+class COption_HTLCClaimZ;
+class CVec_CVec_u8ZZ;
+class CResult_COption_CustomOnionMessageContentsZDecodeErrorZ;
+class CResult_ShutdownScriptDecodeErrorZ;
+class CResult_ProbabilisticScorerDecodeErrorZ;
+class CResult_TxCreationKeysDecodeErrorZ;
+class C2Tuple_usizeTransactionZ;
+class CResult_NodeAnnouncementDecodeErrorZ;
+class CResult_BlindedPathDecodeErrorZ;
+class CVec_ChannelMonitorZ;
+class CResult_RouteHopDecodeErrorZ;
+class CVec_BalanceZ;
 class CResult_FundingSignedDecodeErrorZ;
+class CResult_RecoverableSignatureNoneZ;
+class C2Tuple_Z;
+class C3Tuple_RawInvoice_u832InvoiceSignatureZ;
 class CResult_NetworkGraphDecodeErrorZ;
-class CVec_RouteHopZ;
-class CResult_NonePaymentSendFailureZ;
 class CResult_NodeInfoDecodeErrorZ;
+class CVec_NodeIdZ;
 class CResult_RouteLightningErrorZ;
 class CResult_ChannelPublicKeysDecodeErrorZ;
-class CVec_NodeIdZ;
 class CVec_u8Z;
-class CVec_C2Tuple_BlockHashChannelMonitorZZ;
-class CVec_ThirtyTwoBytesZ;
-class CResult_ClosingSignedDecodeErrorZ;
+class CResult_NonePaymentSendFailureZ;
 class CResult_HolderCommitmentTransactionDecodeErrorZ;
-class CVec_CResult_NoneAPIErrorZZ;
-class CResult_CounterpartyCommitmentSecretsDecodeErrorZ;
-class CResult_ChannelCounterpartyDecodeErrorZ;
 class CResult_WarningMessageDecodeErrorZ;
+class CResult_ChannelCounterpartyDecodeErrorZ;
 class CResult_SignatureNoneZ;
-class CVec_RouteHintHopZ;
-class CResult_SecretKeyNoneZ;
-class CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ;
 class C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ;
-class CResult_PaymentParametersDecodeErrorZ;
-class CResult_PaymentPurposeDecodeErrorZ;
 class CResult_InitDecodeErrorZ;
+class CVec_MonitorUpdateIdZ;
+class CResult_PaymentPurposeDecodeErrorZ;
 class CResult_OutPointDecodeErrorZ;
 class CVec_ChannelDetailsZ;
-class CResult_SignDecodeErrorZ;
-class C2Tuple_OutPointCVec_MonitorEventZZ;
 class CVec_MessageSendEventZ;
 class COption_NetAddressZ;
 class C2Tuple_OutPointScriptZ;
 class CResult_RouteHintHopDecodeErrorZ;
-class CResult_C2Tuple_SignatureSignatureZNoneZ;
-class CVec_NodeAnnouncementZ;
 class CResult_UpdateFailMalformedHTLCDecodeErrorZ;
-class CResult_UnsignedChannelAnnouncementDecodeErrorZ;
-class CVec_TxidZ;
-class COption_AccessZ;
+class CResult_SharedSecretNoneZ;
 class CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ;
-class CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ;
-class CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ;
 class CResult_CVec_CVec_u8ZZNoneZ;
-class C2Tuple_SignatureSignatureZ;
 class C2Tuple_PaymentHashPaymentSecretZ;
-class C2Tuple_BlockHashChannelManagerZ;
-class CResult_ChannelTransactionParametersDecodeErrorZ;
 class CResult_AcceptChannelDecodeErrorZ;
 class CVec_SignatureZ;
 class CVec_u64Z;
-class CResult_PongDecodeErrorZ;
-class CResult_DelayedPaymentOutputDescriptorDecodeErrorZ;
-class C2Tuple_PaymentHashPaymentIdZ;
-class CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ;
-class CResult_NoneErrorZ;
 class CResult_StringErrorZ;
 class C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ;
 class CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ;
 class COption_EventZ;
 class CResult_ChannelTypeFeaturesDecodeErrorZ;
-class CResult_SiPrefixParseErrorZ;
 class CVec_RouteHintZ;
 class COption_u16Z;
 class CVec_CVec_RouteHopZZ;
-class CResult_TrustedCommitmentTransactionNoneZ;
-class CResult_FixedPenaltyScorerDecodeErrorZ;
-class CResult_NoneLightningErrorZ;
-class CResult_NonePeerHandleErrorZ;
-class CResult_COption_EventZDecodeErrorZ;
-class CResult_CVec_SignatureZNoneZ;
-class COption_CVec_NetAddressZZ;
-class CResult__u832APIErrorZ;
-class CResult_PaymentIdPaymentErrorZ;
-class CResult_DescriptionCreationErrorZ;
-class CResult_RoutingFeesDecodeErrorZ;
-class CResult_PayeePubKeyErrorZ;
-class CResult_COption_MonitorEventZDecodeErrorZ;
 class CVec_C2Tuple_PublicKeyTypeZZ;
+class C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ;
 class CResult_u32GraphSyncErrorZ;
-class CResult_InvoiceSemanticErrorZ;
-class CResult_UpdateAddHTLCDecodeErrorZ;
-class CResult_QueryShortChannelIdsDecodeErrorZ;
-class CResult_CounterpartyChannelTransactionParametersDecodeErrorZ;
+class CVec_PhantomRouteHintsZ;
 class CResult_NoneAPIErrorZ;
+class CResult_CounterpartyChannelTransactionParametersDecodeErrorZ;
 class CVec_NetAddressZ;
 class CResult_ChannelDetailsDecodeErrorZ;
 class CVec_PublicKeyZ;
 class CVec_C2Tuple_usizeTransactionZZ;
-class CVec_PhantomRouteHintsZ;
-class COption_MonitorEventZ;
 class C2Tuple_u64u64Z;
-class COption_TypeZ;
-class CResult_COption_TypeZDecodeErrorZ;
 class C2Tuple_u32TxOutZ;
-class CResult_UpdateFailHTLCDecodeErrorZ;
-class CResult_InvoiceParseOrSemanticErrorZ;
 class CResult_PaymentSecretNoneZ;
 class CResult_ChannelConfigDecodeErrorZ;
 class CVec_PrivateRouteZ;
-class CResult_SpendableOutputDescriptorDecodeErrorZ;
-class CResult_RevokeAndACKDecodeErrorZ;
-class CResult_UnsignedChannelUpdateDecodeErrorZ;
+class CResult_BlindedPathNoneZ;
 class CResult_ShutdownDecodeErrorZ;
-class CVec_EventZ;
-class CResult_NoneSemanticErrorZ;
+class CResult_TxOutUtxoLookupErrorZ;
 class CVec_MonitorEventZ;
 class CVec_PaymentPreimageZ;
-class CVec_C2Tuple_u32ScriptZZ;
-class CResult_NoneChannelMonitorUpdateErrZ;
-class CResult_COption_ClosureReasonZDecodeErrorZ;
 class CResult_PublicKeyErrorZ;
-class C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ;
+class CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ;
 class CResult_NoneNoneZ;
-class CResult_RouteParametersDecodeErrorZ;
 class COption_ClosureReasonZ;
-class CResult_NodeAliasDecodeErrorZ;
+class COption_u128Z;
 class CVec_APIErrorZ;
-class CResult_PrivateRouteCreationErrorZ;
 class CResult_boolPeerHandleErrorZ;
-class CVec_UpdateFulfillHTLCZ;
-class CResult_AnnouncementSignaturesDecodeErrorZ;
-class CResult_UpdateFulfillHTLCDecodeErrorZ;
 class CResult_ChannelUpdateDecodeErrorZ;
-class CResult_NodeFeaturesDecodeErrorZ;
-class CVec_u5Z;
-class CResult_InMemorySignerDecodeErrorZ;
 class CResult_PaymentSecretAPIErrorZ;
 class CResult_CounterpartyForwardingInfoDecodeErrorZ;
-class CResult_SignedRawInvoiceParseErrorZ;
 class C2Tuple_u32ScriptZ;
+class CResult_SignedRawInvoiceParseErrorZ;
+class COption_C2Tuple_EightU16sEightU16sZZ;
 class CResult_RouteDecodeErrorZ;
-class CResult_BuiltCommitmentTransactionDecodeErrorZ;
 class COption_NoneZ;
-class CVec_TxOutZ;
-class CResult_ChannelUpdateInfoDecodeErrorZ;
-class CVec_C2Tuple_OutPointCVec_MonitorEventZZZ;
-class CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ;
-class CVec_UpdateFailHTLCZ;
-class CResult_ReplyShortChannelIdsEndDecodeErrorZ;
 
 class Str {
 private:
@@ -413,20 +472,78 @@ public:
 	const LDKStr* operator &() const { return &self; }
 	const LDKStr* operator ->() const { return &self; }
 };
-class CounterpartyCommitmentSecrets {
+class Retry {
 private:
-	LDKCounterpartyCommitmentSecrets self;
+	LDKRetry self;
 public:
-	CounterpartyCommitmentSecrets(const CounterpartyCommitmentSecrets&) = delete;
-	CounterpartyCommitmentSecrets(CounterpartyCommitmentSecrets&& o) : self(o.self) { memset(&o, 0, sizeof(CounterpartyCommitmentSecrets)); }
-	CounterpartyCommitmentSecrets(LDKCounterpartyCommitmentSecrets&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCounterpartyCommitmentSecrets)); }
-	operator LDKCounterpartyCommitmentSecrets() && { LDKCounterpartyCommitmentSecrets res = self; memset(&self, 0, sizeof(LDKCounterpartyCommitmentSecrets)); return res; }
-	~CounterpartyCommitmentSecrets() { CounterpartyCommitmentSecrets_free(self); }
-	CounterpartyCommitmentSecrets& operator=(CounterpartyCommitmentSecrets&& o) { CounterpartyCommitmentSecrets_free(self); self = o.self; memset(&o, 0, sizeof(CounterpartyCommitmentSecrets)); return *this; }
-	LDKCounterpartyCommitmentSecrets* operator &() { return &self; }
-	LDKCounterpartyCommitmentSecrets* operator ->() { return &self; }
-	const LDKCounterpartyCommitmentSecrets* operator &() const { return &self; }
-	const LDKCounterpartyCommitmentSecrets* operator ->() const { return &self; }
+	Retry(const Retry&) = delete;
+	Retry(Retry&& o) : self(o.self) { memset(&o, 0, sizeof(Retry)); }
+	Retry(LDKRetry&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRetry)); }
+	operator LDKRetry() && { LDKRetry res = self; memset(&self, 0, sizeof(LDKRetry)); return res; }
+	~Retry() { Retry_free(self); }
+	Retry& operator=(Retry&& o) { Retry_free(self); self = o.self; memset(&o, 0, sizeof(Retry)); return *this; }
+	LDKRetry* operator &() { return &self; }
+	LDKRetry* operator ->() { return &self; }
+	const LDKRetry* operator &() const { return &self; }
+	const LDKRetry* operator ->() const { return &self; }
+};
+class RetryableSendFailure {
+private:
+	LDKRetryableSendFailure self;
+public:
+	RetryableSendFailure(const RetryableSendFailure&) = delete;
+	RetryableSendFailure(RetryableSendFailure&& o) : self(o.self) { memset(&o, 0, sizeof(RetryableSendFailure)); }
+	RetryableSendFailure(LDKRetryableSendFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRetryableSendFailure)); }
+	operator LDKRetryableSendFailure() && { LDKRetryableSendFailure res = self; memset(&self, 0, sizeof(LDKRetryableSendFailure)); return res; }
+	RetryableSendFailure& operator=(RetryableSendFailure&& o) { self = o.self; memset(&o, 0, sizeof(RetryableSendFailure)); return *this; }
+	LDKRetryableSendFailure* operator &() { return &self; }
+	LDKRetryableSendFailure* operator ->() { return &self; }
+	const LDKRetryableSendFailure* operator &() const { return &self; }
+	const LDKRetryableSendFailure* operator ->() const { return &self; }
+};
+class PaymentSendFailure {
+private:
+	LDKPaymentSendFailure self;
+public:
+	PaymentSendFailure(const PaymentSendFailure&) = delete;
+	PaymentSendFailure(PaymentSendFailure&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentSendFailure)); }
+	PaymentSendFailure(LDKPaymentSendFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentSendFailure)); }
+	operator LDKPaymentSendFailure() && { LDKPaymentSendFailure res = self; memset(&self, 0, sizeof(LDKPaymentSendFailure)); return res; }
+	~PaymentSendFailure() { PaymentSendFailure_free(self); }
+	PaymentSendFailure& operator=(PaymentSendFailure&& o) { PaymentSendFailure_free(self); self = o.self; memset(&o, 0, sizeof(PaymentSendFailure)); return *this; }
+	LDKPaymentSendFailure* operator &() { return &self; }
+	LDKPaymentSendFailure* operator ->() { return &self; }
+	const LDKPaymentSendFailure* operator &() const { return &self; }
+	const LDKPaymentSendFailure* operator ->() const { return &self; }
+};
+class HTLCClaim {
+private:
+	LDKHTLCClaim self;
+public:
+	HTLCClaim(const HTLCClaim&) = delete;
+	HTLCClaim(HTLCClaim&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCClaim)); }
+	HTLCClaim(LDKHTLCClaim&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCClaim)); }
+	operator LDKHTLCClaim() && { LDKHTLCClaim res = self; memset(&self, 0, sizeof(LDKHTLCClaim)); return res; }
+	HTLCClaim& operator=(HTLCClaim&& o) { self = o.self; memset(&o, 0, sizeof(HTLCClaim)); return *this; }
+	LDKHTLCClaim* operator &() { return &self; }
+	LDKHTLCClaim* operator ->() { return &self; }
+	const LDKHTLCClaim* operator &() const { return &self; }
+	const LDKHTLCClaim* operator ->() const { return &self; }
+};
+class CounterpartyCommitmentSecrets {
+private:
+	LDKCounterpartyCommitmentSecrets self;
+public:
+	CounterpartyCommitmentSecrets(const CounterpartyCommitmentSecrets&) = delete;
+	CounterpartyCommitmentSecrets(CounterpartyCommitmentSecrets&& o) : self(o.self) { memset(&o, 0, sizeof(CounterpartyCommitmentSecrets)); }
+	CounterpartyCommitmentSecrets(LDKCounterpartyCommitmentSecrets&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCounterpartyCommitmentSecrets)); }
+	operator LDKCounterpartyCommitmentSecrets() && { LDKCounterpartyCommitmentSecrets res = self; memset(&self, 0, sizeof(LDKCounterpartyCommitmentSecrets)); return res; }
+	~CounterpartyCommitmentSecrets() { CounterpartyCommitmentSecrets_free(self); }
+	CounterpartyCommitmentSecrets& operator=(CounterpartyCommitmentSecrets&& o) { CounterpartyCommitmentSecrets_free(self); self = o.self; memset(&o, 0, sizeof(CounterpartyCommitmentSecrets)); return *this; }
+	LDKCounterpartyCommitmentSecrets* operator &() { return &self; }
+	LDKCounterpartyCommitmentSecrets* operator ->() { return &self; }
+	const LDKCounterpartyCommitmentSecrets* operator &() const { return &self; }
+	const LDKCounterpartyCommitmentSecrets* operator ->() const { return &self; }
 };
 class TxCreationKeys {
 private:
@@ -638,6 +755,36 @@ public:
 	const LDKInvalidShutdownScript* operator &() const { return &self; }
 	const LDKInvalidShutdownScript* operator ->() const { return &self; }
 };
+class BlindedPath {
+private:
+	LDKBlindedPath self;
+public:
+	BlindedPath(const BlindedPath&) = delete;
+	BlindedPath(BlindedPath&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedPath)); }
+	BlindedPath(LDKBlindedPath&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedPath)); }
+	operator LDKBlindedPath() && { LDKBlindedPath res = self; memset(&self, 0, sizeof(LDKBlindedPath)); return res; }
+	~BlindedPath() { BlindedPath_free(self); }
+	BlindedPath& operator=(BlindedPath&& o) { BlindedPath_free(self); self = o.self; memset(&o, 0, sizeof(BlindedPath)); return *this; }
+	LDKBlindedPath* operator &() { return &self; }
+	LDKBlindedPath* operator ->() { return &self; }
+	const LDKBlindedPath* operator &() const { return &self; }
+	const LDKBlindedPath* 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 BackgroundProcessor {
 private:
 	LDKBackgroundProcessor self;
@@ -668,6 +815,79 @@ public:
 	const LDKGossipSync* operator &() const { return &self; }
 	const LDKGossipSync* operator ->() const { return &self; }
 };
+class DefaultRouter {
+private:
+	LDKDefaultRouter self;
+public:
+	DefaultRouter(const DefaultRouter&) = delete;
+	DefaultRouter(DefaultRouter&& o) : self(o.self) { memset(&o, 0, sizeof(DefaultRouter)); }
+	DefaultRouter(LDKDefaultRouter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDefaultRouter)); }
+	operator LDKDefaultRouter() && { LDKDefaultRouter res = self; memset(&self, 0, sizeof(LDKDefaultRouter)); return res; }
+	~DefaultRouter() { DefaultRouter_free(self); }
+	DefaultRouter& operator=(DefaultRouter&& o) { DefaultRouter_free(self); self = o.self; memset(&o, 0, sizeof(DefaultRouter)); return *this; }
+	LDKDefaultRouter* operator &() { return &self; }
+	LDKDefaultRouter* operator ->() { return &self; }
+	const LDKDefaultRouter* operator &() const { return &self; }
+	const LDKDefaultRouter* operator ->() const { return &self; }
+};
+class Router {
+private:
+	LDKRouter self;
+public:
+	Router(const Router&) = delete;
+	Router(Router&& o) : self(o.self) { memset(&o, 0, sizeof(Router)); }
+	Router(LDKRouter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouter)); }
+	operator LDKRouter() && { LDKRouter res = self; memset(&self, 0, sizeof(LDKRouter)); return res; }
+	~Router() { Router_free(self); }
+	Router& operator=(Router&& o) { Router_free(self); self = o.self; memset(&o, 0, sizeof(Router)); return *this; }
+	LDKRouter* operator &() { return &self; }
+	LDKRouter* operator ->() { return &self; }
+	const LDKRouter* operator &() const { return &self; }
+	const LDKRouter* operator ->() const { return &self; }
+	/**
+	 *  Finds a [`Route`] between `payer` and `payee` for a payment with the given values.
+	 * 
+	 *  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, struct LDKCVec_ChannelDetailsZ *first_hops, const struct LDKInFlightHtlcs *NONNULL_PTR inflight_htlcs);
+	/**
+	 *  Finds a [`Route`] between `payer` and `payee` for a payment with the given values. Includes
+	 *  `PaymentHash` and `PaymentId` to be able to correlate the request with a specific payment.
+	 * 
+	 *  Note that first_hops (or a relevant inner pointer) may be NULL or all-0s to represent None
+	 */
+	inline LDK::CResult_RouteLightningErrorZ find_route_with_id(struct LDKPublicKey payer, const struct LDKRouteParameters *NONNULL_PTR route_params, struct LDKCVec_ChannelDetailsZ *first_hops, const struct LDKInFlightHtlcs *NONNULL_PTR inflight_htlcs, struct LDKThirtyTwoBytes _payment_hash, struct LDKThirtyTwoBytes _payment_id);
+};
+class ScorerAccountingForInFlightHtlcs {
+private:
+	LDKScorerAccountingForInFlightHtlcs self;
+public:
+	ScorerAccountingForInFlightHtlcs(const ScorerAccountingForInFlightHtlcs&) = delete;
+	ScorerAccountingForInFlightHtlcs(ScorerAccountingForInFlightHtlcs&& o) : self(o.self) { memset(&o, 0, sizeof(ScorerAccountingForInFlightHtlcs)); }
+	ScorerAccountingForInFlightHtlcs(LDKScorerAccountingForInFlightHtlcs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKScorerAccountingForInFlightHtlcs)); }
+	operator LDKScorerAccountingForInFlightHtlcs() && { LDKScorerAccountingForInFlightHtlcs res = self; memset(&self, 0, sizeof(LDKScorerAccountingForInFlightHtlcs)); return res; }
+	~ScorerAccountingForInFlightHtlcs() { ScorerAccountingForInFlightHtlcs_free(self); }
+	ScorerAccountingForInFlightHtlcs& operator=(ScorerAccountingForInFlightHtlcs&& o) { ScorerAccountingForInFlightHtlcs_free(self); self = o.self; memset(&o, 0, sizeof(ScorerAccountingForInFlightHtlcs)); return *this; }
+	LDKScorerAccountingForInFlightHtlcs* operator &() { return &self; }
+	LDKScorerAccountingForInFlightHtlcs* operator ->() { return &self; }
+	const LDKScorerAccountingForInFlightHtlcs* operator &() const { return &self; }
+	const LDKScorerAccountingForInFlightHtlcs* 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 RouteHop {
 private:
 	LDKRouteHop self;
@@ -808,12 +1028,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);
 };
@@ -832,6 +1052,21 @@ public:
 	const LDKPaymentPurpose* operator &() const { return &self; }
 	const LDKPaymentPurpose* operator ->() const { return &self; }
 };
+class PathFailure {
+private:
+	LDKPathFailure self;
+public:
+	PathFailure(const PathFailure&) = delete;
+	PathFailure(PathFailure&& o) : self(o.self) { memset(&o, 0, sizeof(PathFailure)); }
+	PathFailure(LDKPathFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPathFailure)); }
+	operator LDKPathFailure() && { LDKPathFailure res = self; memset(&self, 0, sizeof(LDKPathFailure)); return res; }
+	~PathFailure() { PathFailure_free(self); }
+	PathFailure& operator=(PathFailure&& o) { PathFailure_free(self); self = o.self; memset(&o, 0, sizeof(PathFailure)); return *this; }
+	LDKPathFailure* operator &() { return &self; }
+	LDKPathFailure* operator ->() { return &self; }
+	const LDKPathFailure* operator &() const { return &self; }
+	const LDKPathFailure* operator ->() const { return &self; }
+};
 class ClosureReason {
 private:
 	LDKClosureReason self;
@@ -847,6 +1082,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 +1147,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 +1185,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);
 };
@@ -939,7 +1208,7 @@ public:
 	 * 
 	 *  See [`EventsProvider`] for details that must be considered when implementing this method.
 	 */
-	inline void handle_event(const struct LDKEvent *NONNULL_PTR event);
+	inline void handle_event(struct LDKEvent event);
 };
 class BestBlock {
 private:
@@ -956,43 +1225,6 @@ public:
 	const LDKBestBlock* operator &() const { return &self; }
 	const LDKBestBlock* operator ->() const { return &self; }
 };
-class AccessError {
-private:
-	LDKAccessError self;
-public:
-	AccessError(const AccessError&) = delete;
-	AccessError(AccessError&& o) : self(o.self) { memset(&o, 0, sizeof(AccessError)); }
-	AccessError(LDKAccessError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAccessError)); }
-	operator LDKAccessError() && { LDKAccessError res = self; memset(&self, 0, sizeof(LDKAccessError)); return res; }
-	AccessError& operator=(AccessError&& o) { self = o.self; memset(&o, 0, sizeof(AccessError)); return *this; }
-	LDKAccessError* operator &() { return &self; }
-	LDKAccessError* operator ->() { return &self; }
-	const LDKAccessError* operator &() const { return &self; }
-	const LDKAccessError* operator ->() const { return &self; }
-};
-class Access {
-private:
-	LDKAccess self;
-public:
-	Access(const Access&) = delete;
-	Access(Access&& o) : self(o.self) { memset(&o, 0, sizeof(Access)); }
-	Access(LDKAccess&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAccess)); }
-	operator LDKAccess() && { LDKAccess res = self; memset(&self, 0, sizeof(LDKAccess)); return res; }
-	~Access() { Access_free(self); }
-	Access& operator=(Access&& o) { Access_free(self); self = o.self; memset(&o, 0, sizeof(Access)); return *this; }
-	LDKAccess* operator &() { return &self; }
-	LDKAccess* operator ->() { return &self; }
-	const LDKAccess* operator &() const { return &self; }
-	const LDKAccess* operator ->() const { return &self; }
-	/**
-	 *  Returns the transaction output of a funding transaction encoded by [`short_channel_id`].
-	 *  Returns an error if `genesis_hash` is for a different chain or if such a transaction output
-	 *  is unknown.
-	 * 
-	 *  [`short_channel_id`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#definition-of-short_channel_id
-	 */
-	inline LDK::CResult_TxOutAccessErrorZ get_utxo(const uint8_t (*genesis_hash)[32], uint64_t short_channel_id);
-};
 class Listen {
 private:
 	LDKListen self;
@@ -1036,9 +1268,9 @@ public:
 	const LDKConfirm* operator &() const { return &self; }
 	const LDKConfirm* operator ->() const { return &self; }
 	/**
-	 *  Processes transactions confirmed in a block with a given header and height.
+	 *  Notifies LDK of transactions confirmed in a block with a given header and height.
 	 * 
-	 *  Should be called for any transactions registered by [`Filter::register_tx`] or any
+	 *  Must be called for any transactions registered by [`Filter::register_tx`] or any
 	 *  transactions spending an output registered by [`Filter::register_output`]. Such transactions
 	 *  appearing in the same block do not need to be included in the same call; instead, multiple
 	 *  calls with additional transactions may be made so long as they are made in [chain order].
@@ -1047,58 +1279,67 @@ 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);
 	/**
-	 *  Processes a transaction that is no longer confirmed as result of a chain reorganization.
+	 *  Notifies LDK of 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`].
+	 *  Must be called for any transaction returned by [`get_relevant_txids`] if it has been
+	 *  reorganized out of the best chain or if it is no longer confirmed in the block with the
+	 *  given block hash. 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
 	 */
 	inline void transaction_unconfirmed(const uint8_t (*txid)[32]);
 	/**
-	 *  Processes an update to the best header connected at the given height.
+	 *  Notifies LDK of an update to the best header connected at the given height.
 	 * 
-	 *  Should be called when a new header is available but may be skipped for intermediary blocks
-	 *  if they become available at the same time.
+	 *  Must be called whenever a new chain tip becomes available. May be skipped for intermediary
+	 *  blocks.
 	 */
 	inline void best_block_updated(const uint8_t (*header)[80], uint32_t height);
 	/**
-	 *  Returns transactions that should be monitored for reorganization out of the chain.
+	 *  Returns transactions that must be monitored for reorganization out of the chain along
+	 *  with the hash of the block as part of which it had been previously confirmed.
+	 * 
+	 *  Note that the returned `Option<BlockHash>` might be `None` for channels created with LDK
+	 *  0.0.112 and prior, in which case you need to manually track previous confirmations.
 	 * 
-	 *  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
+	 *  Must be called to determine the subset of transactions that must be monitored for
 	 *  reorganization. Will be idempotent between calls but may change as a result of calls to the
-	 *  other interface methods. Thus, this is useful to determine which transactions may need to be
+	 *  other interface methods. Thus, this is useful to determine which transactions must be
 	 *  given to [`transaction_unconfirmed`].
 	 * 
+	 *  If any of the returned transactions are confirmed in a block other than the one with the
+	 *  given hash, they need to be unconfirmed and reconfirmed via [`transaction_unconfirmed`] and
+	 *  [`transactions_confirmed`], respectively.
+	 * 
 	 *  [`transactions_confirmed`]: Self::transactions_confirmed
 	 *  [`transaction_unconfirmed`]: Self::transaction_unconfirmed
 	 */
-	inline LDK::CVec_TxidZ get_relevant_txids();
+	inline LDK::CVec_C2Tuple_TxidBlockHashZZ 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 +1362,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, const struct LDKChannelMonitorUpdate *NONNULL_PTR update);
 	/**
 	 *  Returns any monitor events since the last call. Subsequent calls must only return new
 	 *  events.
@@ -1147,9 +1388,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 +1414,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 +1469,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 +1497,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 +1527,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;
@@ -1386,6 +1662,66 @@ public:
 	const LDKInvoiceFeatures* operator &() const { return &self; }
 	const LDKInvoiceFeatures* operator ->() const { return &self; }
 };
+class OfferFeatures {
+private:
+	LDKOfferFeatures self;
+public:
+	OfferFeatures(const OfferFeatures&) = delete;
+	OfferFeatures(OfferFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(OfferFeatures)); }
+	OfferFeatures(LDKOfferFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOfferFeatures)); }
+	operator LDKOfferFeatures() && { LDKOfferFeatures res = self; memset(&self, 0, sizeof(LDKOfferFeatures)); return res; }
+	~OfferFeatures() { OfferFeatures_free(self); }
+	OfferFeatures& operator=(OfferFeatures&& o) { OfferFeatures_free(self); self = o.self; memset(&o, 0, sizeof(OfferFeatures)); return *this; }
+	LDKOfferFeatures* operator &() { return &self; }
+	LDKOfferFeatures* operator ->() { return &self; }
+	const LDKOfferFeatures* operator &() const { return &self; }
+	const LDKOfferFeatures* operator ->() const { return &self; }
+};
+class InvoiceRequestFeatures {
+private:
+	LDKInvoiceRequestFeatures self;
+public:
+	InvoiceRequestFeatures(const InvoiceRequestFeatures&) = delete;
+	InvoiceRequestFeatures(InvoiceRequestFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceRequestFeatures)); }
+	InvoiceRequestFeatures(LDKInvoiceRequestFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceRequestFeatures)); }
+	operator LDKInvoiceRequestFeatures() && { LDKInvoiceRequestFeatures res = self; memset(&self, 0, sizeof(LDKInvoiceRequestFeatures)); return res; }
+	~InvoiceRequestFeatures() { InvoiceRequestFeatures_free(self); }
+	InvoiceRequestFeatures& operator=(InvoiceRequestFeatures&& o) { InvoiceRequestFeatures_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceRequestFeatures)); return *this; }
+	LDKInvoiceRequestFeatures* operator &() { return &self; }
+	LDKInvoiceRequestFeatures* operator ->() { return &self; }
+	const LDKInvoiceRequestFeatures* operator &() const { return &self; }
+	const LDKInvoiceRequestFeatures* operator ->() const { return &self; }
+};
+class Bolt12InvoiceFeatures {
+private:
+	LDKBolt12InvoiceFeatures self;
+public:
+	Bolt12InvoiceFeatures(const Bolt12InvoiceFeatures&) = delete;
+	Bolt12InvoiceFeatures(Bolt12InvoiceFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt12InvoiceFeatures)); }
+	Bolt12InvoiceFeatures(LDKBolt12InvoiceFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt12InvoiceFeatures)); }
+	operator LDKBolt12InvoiceFeatures() && { LDKBolt12InvoiceFeatures res = self; memset(&self, 0, sizeof(LDKBolt12InvoiceFeatures)); return res; }
+	~Bolt12InvoiceFeatures() { Bolt12InvoiceFeatures_free(self); }
+	Bolt12InvoiceFeatures& operator=(Bolt12InvoiceFeatures&& o) { Bolt12InvoiceFeatures_free(self); self = o.self; memset(&o, 0, sizeof(Bolt12InvoiceFeatures)); return *this; }
+	LDKBolt12InvoiceFeatures* operator &() { return &self; }
+	LDKBolt12InvoiceFeatures* operator ->() { return &self; }
+	const LDKBolt12InvoiceFeatures* operator &() const { return &self; }
+	const LDKBolt12InvoiceFeatures* operator ->() const { return &self; }
+};
+class BlindedHopFeatures {
+private:
+	LDKBlindedHopFeatures self;
+public:
+	BlindedHopFeatures(const BlindedHopFeatures&) = delete;
+	BlindedHopFeatures(BlindedHopFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedHopFeatures)); }
+	BlindedHopFeatures(LDKBlindedHopFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedHopFeatures)); }
+	operator LDKBlindedHopFeatures() && { LDKBlindedHopFeatures res = self; memset(&self, 0, sizeof(LDKBlindedHopFeatures)); return res; }
+	~BlindedHopFeatures() { BlindedHopFeatures_free(self); }
+	BlindedHopFeatures& operator=(BlindedHopFeatures&& o) { BlindedHopFeatures_free(self); self = o.self; memset(&o, 0, sizeof(BlindedHopFeatures)); return *this; }
+	LDKBlindedHopFeatures* operator &() { return &self; }
+	LDKBlindedHopFeatures* operator ->() { return &self; }
+	const LDKBlindedHopFeatures* operator &() const { return &self; }
+	const LDKBlindedHopFeatures* operator ->() const { return &self; }
+};
 class ChannelTypeFeatures {
 private:
 	LDKChannelTypeFeatures self;
@@ -1401,6 +1737,40 @@ public:
 	const LDKChannelTypeFeatures* operator &() const { return &self; }
 	const LDKChannelTypeFeatures* operator ->() const { return &self; }
 };
+class OnionMessageContents {
+private:
+	LDKOnionMessageContents self;
+public:
+	OnionMessageContents(const OnionMessageContents&) = delete;
+	OnionMessageContents(OnionMessageContents&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessageContents)); }
+	OnionMessageContents(LDKOnionMessageContents&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessageContents)); }
+	operator LDKOnionMessageContents() && { LDKOnionMessageContents res = self; memset(&self, 0, sizeof(LDKOnionMessageContents)); return res; }
+	~OnionMessageContents() { OnionMessageContents_free(self); }
+	OnionMessageContents& operator=(OnionMessageContents&& o) { OnionMessageContents_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessageContents)); return *this; }
+	LDKOnionMessageContents* operator &() { return &self; }
+	LDKOnionMessageContents* operator ->() { return &self; }
+	const LDKOnionMessageContents* operator &() const { return &self; }
+	const LDKOnionMessageContents* 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;
@@ -1641,24 +2011,24 @@ public:
 	const LDKSpendableOutputDescriptor* operator &() const { return &self; }
 	const LDKSpendableOutputDescriptor* operator ->() const { return &self; }
 };
-class BaseSign {
+class ChannelSigner {
 private:
-	LDKBaseSign self;
+	LDKChannelSigner self;
 public:
-	BaseSign(const BaseSign&) = delete;
-	BaseSign(BaseSign&& o) : self(o.self) { memset(&o, 0, sizeof(BaseSign)); }
-	BaseSign(LDKBaseSign&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBaseSign)); }
-	operator LDKBaseSign() && { LDKBaseSign res = self; memset(&self, 0, sizeof(LDKBaseSign)); return res; }
-	~BaseSign() { BaseSign_free(self); }
-	BaseSign& operator=(BaseSign&& o) { BaseSign_free(self); self = o.self; memset(&o, 0, sizeof(BaseSign)); return *this; }
-	LDKBaseSign* operator &() { return &self; }
-	LDKBaseSign* operator ->() { return &self; }
-	const LDKBaseSign* operator &() const { return &self; }
-	const LDKBaseSign* operator ->() const { return &self; }
+	ChannelSigner(const ChannelSigner&) = delete;
+	ChannelSigner(ChannelSigner&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelSigner)); }
+	ChannelSigner(LDKChannelSigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelSigner)); }
+	operator LDKChannelSigner() && { LDKChannelSigner res = self; memset(&self, 0, sizeof(LDKChannelSigner)); return res; }
+	~ChannelSigner() { ChannelSigner_free(self); }
+	ChannelSigner& operator=(ChannelSigner&& o) { ChannelSigner_free(self); self = o.self; memset(&o, 0, sizeof(ChannelSigner)); return *this; }
+	LDKChannelSigner* operator &() { return &self; }
+	LDKChannelSigner* operator ->() { return &self; }
+	const LDKChannelSigner* operator &() const { return &self; }
+	const LDKChannelSigner* operator ->() const { return &self; }
 	/**
 	 *  Gets the per-commitment point for a specific commitment number
 	 * 
-	 *  Note that the commitment number starts at (1 << 48) - 1 and counts backwards.
+	 *  Note that the commitment number starts at `(1 << 48) - 1` and counts backwards.
 	 */
 	inline LDKPublicKey get_per_commitment_point(uint64_t idx);
 	/**
@@ -1669,7 +2039,7 @@ public:
 	 * 
 	 *  May be called more than once for the same index.
 	 * 
-	 *  Note that the commitment number starts at (1 << 48) - 1 and counts backwards.
+	 *  Note that the commitment number starts at `(1 << 48) - 1` and counts backwards.
 	 */
 	inline LDKThirtyTwoBytes release_commitment_secret(uint64_t idx);
 	/**
@@ -1684,16 +2054,43 @@ public:
 	 *  A validating signer should ensure that an HTLC output is removed only when the matching
 	 *  preimage is provided, or when the value to holder is restored.
 	 * 
-	 *  NOTE: all the relevant preimages will be provided, but there may also be additional
+	 *  Note that all the relevant preimages will be provided, but there may also be additional
 	 *  irrelevant or duplicate preimages.
 	 */
 	inline LDK::CResult_NoneNoneZ validate_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_PaymentPreimageZ preimages);
 	/**
-	 *  Gets an arbitrary identifier describing the set of keys which are provided back to you in
-	 *  some SpendableOutputDescriptor types. This should be sufficient to identify this
-	 *  Sign object uniquely and lookup or re-derive its keys.
+	 *  Returns an arbitrary identifier describing the set of keys which are provided back to you in
+	 *  some [`SpendableOutputDescriptor`] types. This should be sufficient to identify this
+	 *  [`EcdsaChannelSigner`] object uniquely and lookup or re-derive its keys.
 	 */
 	inline LDKThirtyTwoBytes channel_keys_id();
+	/**
+	 *  Set the counterparty static channel data, including basepoints,
+	 *  `counterparty_selected`/`holder_selected_contest_delay` and funding outpoint.
+	 * 
+	 *  This data is static, and will never change for a channel once set. For a given [`ChannelSigner`]
+	 *  instance, LDK will call this method exactly once - either immediately after construction
+	 *  (not including if done via [`SignerProvider::read_chan_signer`]) or when the funding
+	 *  information has been generated.
+	 * 
+	 *  channel_parameters.is_populated() MUST be true.
+	 */
+	inline void provide_channel_parameters(const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters);
+};
+class EcdsaChannelSigner {
+private:
+	LDKEcdsaChannelSigner self;
+public:
+	EcdsaChannelSigner(const EcdsaChannelSigner&) = delete;
+	EcdsaChannelSigner(EcdsaChannelSigner&& o) : self(o.self) { memset(&o, 0, sizeof(EcdsaChannelSigner)); }
+	EcdsaChannelSigner(LDKEcdsaChannelSigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEcdsaChannelSigner)); }
+	operator LDKEcdsaChannelSigner() && { LDKEcdsaChannelSigner res = self; memset(&self, 0, sizeof(LDKEcdsaChannelSigner)); return res; }
+	~EcdsaChannelSigner() { EcdsaChannelSigner_free(self); }
+	EcdsaChannelSigner& operator=(EcdsaChannelSigner&& o) { EcdsaChannelSigner_free(self); self = o.self; memset(&o, 0, sizeof(EcdsaChannelSigner)); return *this; }
+	LDKEcdsaChannelSigner* operator &() { return &self; }
+	LDKEcdsaChannelSigner* operator ->() { return &self; }
+	const LDKEcdsaChannelSigner* operator &() const { return &self; }
+	const LDKEcdsaChannelSigner* operator ->() const { return &self; }
 	/**
 	 *  Create a signature for a counterparty's commitment transaction and associated HTLC transactions.
 	 * 
@@ -1706,7 +2103,7 @@ public:
 	 *  A validating signer should ensure that an HTLC output is removed only when the matching
 	 *  preimage is provided, or when the value to holder is restored.
 	 * 
-	 *  NOTE: all the relevant preimages will be provided, but there may also be additional
+	 *  Note that all the relevant preimages will be provided, but there may also be additional
 	 *  irrelevant or duplicate preimages.
 	 */
 	inline LDK::CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ sign_counterparty_commitment(const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx, struct LDKCVec_PaymentPreimageZ preimages);
@@ -1718,17 +2115,21 @@ public:
 	 */
 	inline LDK::CResult_NoneNoneZ validate_counterparty_revocation(uint64_t idx, const uint8_t (*secret)[32]);
 	/**
-	 *  Create a signatures for a holder's commitment transaction and its claiming HTLC transactions.
-	 *  This will only ever be called with a non-revoked commitment_tx.  This will be called with the
-	 *  latest commitment_tx when we initiate a force-close.
-	 *  This will be called with the previous latest, just to get claiming HTLC signatures, if we are
-	 *  reacting to a ChannelMonitor replica that decided to broadcast before it had been updated to
-	 *  the latest.
+	 *  Creates a signature for a holder's commitment transaction and its claiming HTLC transactions.
+	 * 
+	 *  This will be called
+	 *  - with a non-revoked `commitment_tx`.
+	 *  - with the latest `commitment_tx` when we initiate a force-close.
+	 *  - with the previous `commitment_tx`, just to get claiming HTLC
+	 *    signatures, if we are reacting to a [`ChannelMonitor`]
+	 *    [replica](https://github.com/lightningdevkit/rust-lightning/blob/main/GLOSSARY.md#monitor-replicas)
+	 *    that decided to broadcast before it had been updated to the latest `commitment_tx`.
+	 * 
 	 *  This may be called multiple times for the same transaction.
 	 * 
 	 *  An external signer implementation should check that the commitment has not been revoked.
 	 * 
-	 *  May return Err if key derivation fails.  Callers, such as ChannelMonitor, will panic in such a case.
+	 *  [`ChannelMonitor`]: crate::chain::channelmonitor::ChannelMonitor
 	 */
 	inline LDK::CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ sign_holder_commitment_and_htlcs(const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx);
 	/**
@@ -1742,9 +2143,9 @@ public:
 	 * 
 	 *  Amount is value of the output spent by this input, committed to in the BIP 143 signature.
 	 * 
-	 *  per_commitment_key is revocation secret which was provided by our counterparty when they
+	 *  `per_commitment_key` is revocation secret which was provided by our counterparty when they
 	 *  revoked the state which they eventually broadcast. It's not a _holder_ secret key and does
-	 *  not allow the spending of any funds by itself (you need our holder revocation_secret to do
+	 *  not allow the spending of any funds by itself (you need our holder `revocation_secret` to do
 	 *  so).
 	 */
 	inline LDK::CResult_SignatureNoneZ sign_justice_revoked_output(struct LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (*per_commitment_key)[32]);
@@ -1757,14 +2158,15 @@ public:
 	 *  It may be called multiple times for same output(s) if a fee-bump is needed with regards
 	 *  to an upcoming timelock expiration.
 	 * 
-	 *  Amount is value of the output spent by this input, committed to in the BIP 143 signature.
+	 *  `amount` is the value of the output spent by this input, committed to in the BIP 143
+	 *  signature.
 	 * 
-	 *  per_commitment_key is revocation secret which was provided by our counterparty when they
+	 *  `per_commitment_key` is revocation secret which was provided by our counterparty when they
 	 *  revoked the state which they eventually broadcast. It's not a _holder_ secret key and does
 	 *  not allow the spending of any funds by itself (you need our holder revocation_secret to do
 	 *  so).
 	 * 
-	 *  htlc holds HTLC elements (hash, timelock), thus changing the format of the witness script
+	 *  `htlc` holds HTLC elements (hash, timelock), thus changing the format of the witness script
 	 *  (which is committed to in the BIP 143 signatures).
 	 */
 	inline LDK::CResult_SignatureNoneZ sign_justice_revoked_htlc(struct LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (*per_commitment_key)[32], const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc);
@@ -1777,12 +2179,12 @@ public:
 	 *  signed for here. It may be called multiple times for same output(s) if a fee-bump is
 	 *  needed with regards to an upcoming timelock expiration.
 	 * 
-	 *  Witness_script is either a offered or received script as defined in BOLT3 for HTLC
+	 *  `witness_script` is either an offered or received script as defined in BOLT3 for HTLC
 	 *  outputs.
 	 * 
-	 *  Amount is value of the output spent by this input, committed to in the BIP 143 signature.
+	 *  `amount` is value of the output spent by this input, committed to in the BIP 143 signature.
 	 * 
-	 *  Per_commitment_point is the dynamic point corresponding to the channel state
+	 *  `per_commitment_point` is the dynamic point corresponding to the channel state
 	 *  detected onchain. It has been generated by our counterparty and is used to derive
 	 *  channel state keys, which are then included in the witness script and committed to in the
 	 *  BIP 143 signature.
@@ -1796,45 +2198,37 @@ public:
 	 */
 	inline LDK::CResult_SignatureNoneZ sign_closing_transaction(const struct LDKClosingTransaction *NONNULL_PTR closing_tx);
 	/**
-	 *  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.
+	 *  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 proving it comes from one of the
+	 *  channel participants.
 	 * 
-	 *  The first returned signature should be from our node secret key, the second from our
-	 *  funding key.
+	 *  Channel announcements also require a signature from each node's network key. Our node
+	 *  signature is computed through [`NodeSigner::sign_gossip_message`].
 	 * 
 	 *  Note that if this fails or is rejected, the channel will not be publicly announced and
 	 *  our counterparty may (though likely will not) close the channel on us for violating the
 	 *  protocol.
 	 */
-	inline LDK::CResult_C2Tuple_SignatureSignatureZNoneZ sign_channel_announcement(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg);
-	/**
-	 *  Set the counterparty static channel data, including basepoints,
-	 *  counterparty_selected/holder_selected_contest_delay and funding outpoint.
-	 *  This is done as soon as the funding outpoint is known.  Since these are static channel data,
-	 *  they MUST NOT be allowed to change to different values once set.
-	 * 
-	 *  channel_parameters.is_populated() MUST be true.
-	 * 
-	 *  We bind holder_selected_contest_delay late here for API convenience.
-	 * 
-	 *  Will be called before any signatures are applied.
-	 */
-	inline void ready_channel(const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters);
+	inline LDK::CResult_SignatureNoneZ sign_channel_announcement_with_funding_key(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg);
 };
-class Sign {
+class WriteableEcdsaChannelSigner {
 private:
-	LDKSign self;
+	LDKWriteableEcdsaChannelSigner self;
 public:
-	Sign(const Sign&) = delete;
-	Sign(Sign&& o) : self(o.self) { memset(&o, 0, sizeof(Sign)); }
-	Sign(LDKSign&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSign)); }
-	operator LDKSign() && { LDKSign res = self; memset(&self, 0, sizeof(LDKSign)); return res; }
-	~Sign() { Sign_free(self); }
-	Sign& operator=(Sign&& o) { Sign_free(self); self = o.self; memset(&o, 0, sizeof(Sign)); return *this; }
-	LDKSign* operator &() { return &self; }
-	LDKSign* operator ->() { return &self; }
-	const LDKSign* operator &() const { return &self; }
-	const LDKSign* operator ->() const { return &self; }
+	WriteableEcdsaChannelSigner(const WriteableEcdsaChannelSigner&) = delete;
+	WriteableEcdsaChannelSigner(WriteableEcdsaChannelSigner&& o) : self(o.self) { memset(&o, 0, sizeof(WriteableEcdsaChannelSigner)); }
+	WriteableEcdsaChannelSigner(LDKWriteableEcdsaChannelSigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWriteableEcdsaChannelSigner)); }
+	operator LDKWriteableEcdsaChannelSigner() && { LDKWriteableEcdsaChannelSigner res = self; memset(&self, 0, sizeof(LDKWriteableEcdsaChannelSigner)); return res; }
+	~WriteableEcdsaChannelSigner() { WriteableEcdsaChannelSigner_free(self); }
+	WriteableEcdsaChannelSigner& operator=(WriteableEcdsaChannelSigner&& o) { WriteableEcdsaChannelSigner_free(self); self = o.self; memset(&o, 0, sizeof(WriteableEcdsaChannelSigner)); return *this; }
+	LDKWriteableEcdsaChannelSigner* operator &() { return &self; }
+	LDKWriteableEcdsaChannelSigner* operator ->() { return &self; }
+	const LDKWriteableEcdsaChannelSigner* operator &() const { return &self; }
+	const LDKWriteableEcdsaChannelSigner* operator ->() const { return &self; }
 };
 class Recipient {
 private:
@@ -1850,89 +2244,158 @@ public:
 	const LDKRecipient* operator &() const { return &self; }
 	const LDKRecipient* operator ->() const { return &self; }
 };
-class KeysInterface {
+class EntropySource {
+private:
+	LDKEntropySource self;
+public:
+	EntropySource(const EntropySource&) = delete;
+	EntropySource(EntropySource&& o) : self(o.self) { memset(&o, 0, sizeof(EntropySource)); }
+	EntropySource(LDKEntropySource&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEntropySource)); }
+	operator LDKEntropySource() && { LDKEntropySource res = self; memset(&self, 0, sizeof(LDKEntropySource)); return res; }
+	~EntropySource() { EntropySource_free(self); }
+	EntropySource& operator=(EntropySource&& o) { EntropySource_free(self); self = o.self; memset(&o, 0, sizeof(EntropySource)); return *this; }
+	LDKEntropySource* operator &() { return &self; }
+	LDKEntropySource* operator ->() { return &self; }
+	const LDKEntropySource* operator &() const { return &self; }
+	const LDKEntropySource* operator ->() const { return &self; }
+	/**
+	 *  Gets a unique, cryptographically-secure, random 32-byte value. This method must return a
+	 *  different value each time it is called.
+	 */
+	inline LDKThirtyTwoBytes get_secure_random_bytes();
+};
+class NodeSigner {
 private:
-	LDKKeysInterface self;
+	LDKNodeSigner self;
 public:
-	KeysInterface(const KeysInterface&) = delete;
-	KeysInterface(KeysInterface&& o) : self(o.self) { memset(&o, 0, sizeof(KeysInterface)); }
-	KeysInterface(LDKKeysInterface&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKKeysInterface)); }
-	operator LDKKeysInterface() && { LDKKeysInterface res = self; memset(&self, 0, sizeof(LDKKeysInterface)); return res; }
-	~KeysInterface() { KeysInterface_free(self); }
-	KeysInterface& operator=(KeysInterface&& o) { KeysInterface_free(self); self = o.self; memset(&o, 0, sizeof(KeysInterface)); return *this; }
-	LDKKeysInterface* operator &() { return &self; }
-	LDKKeysInterface* operator ->() { return &self; }
-	const LDKKeysInterface* operator &() const { return &self; }
-	const LDKKeysInterface* operator ->() const { return &self; }
+	NodeSigner(const NodeSigner&) = delete;
+	NodeSigner(NodeSigner&& o) : self(o.self) { memset(&o, 0, sizeof(NodeSigner)); }
+	NodeSigner(LDKNodeSigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeSigner)); }
+	operator LDKNodeSigner() && { LDKNodeSigner res = self; memset(&self, 0, sizeof(LDKNodeSigner)); return res; }
+	~NodeSigner() { NodeSigner_free(self); }
+	NodeSigner& operator=(NodeSigner&& o) { NodeSigner_free(self); self = o.self; memset(&o, 0, sizeof(NodeSigner)); return *this; }
+	LDKNodeSigner* operator &() { return &self; }
+	LDKNodeSigner* operator ->() { return &self; }
+	const LDKNodeSigner* operator &() const { return &self; }
+	const LDKNodeSigner* operator ->() const { return &self; }
 	/**
-	 *  Get node secret key based on the provided [`Recipient`].
+	 *  Get secret key material as bytes for use in encrypting and decrypting inbound payment data.
+	 * 
+	 *  If the implementor of this trait supports [phantom node payments], then every node that is
+	 *  intended to be included in the phantom invoice route hints must return the same value from
+	 *  this method.
+	 * 
+	 *  This method must return the same value each time it is called.
 	 * 
-	 *  The node_id/network_key is the public key that corresponds to this secret key.
+	 *  [phantom node payments]: PhantomKeysManager
+	 */
+	inline LDKThirtyTwoBytes get_inbound_payment_key_material();
+	/**
+	 *  Get node id based on the provided [`Recipient`].
 	 * 
-	 *  This method must return the same value each time it is called with a given `Recipient`
+	 *  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);
+	inline LDK::CResult_PublicKeyNoneZ get_node_id(enum LDKRecipient recipient);
 	/**
-	 *  Get a script pubkey which we send funds to when claiming on-chain contestable outputs.
+	 *  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.
 	 * 
-	 *  This method should return a different value each time it is called, to avoid linking
-	 *  on-chain funds across channels as controlled to the same user.
+	 *  Note that if this fails while attempting to forward an HTLC, LDK will panic. The error
+	 *  should be resolved to allow LDK to resume forwarding HTLCs.
+	 * 
+	 *  Errors if the [`Recipient`] variant is not supported by the implementation.
 	 */
-	inline LDK::CVec_u8Z get_destination_script();
+	inline LDK::CResult_SharedSecretNoneZ ecdh(enum LDKRecipient recipient, struct LDKPublicKey other_key, struct LDKCOption_ScalarZ tweak);
 	/**
-	 *  Get a script pubkey which we will send funds to when closing a channel.
+	 *  Sign an invoice.
 	 * 
-	 *  This method should return a different value each time it is called, to avoid linking
-	 *  on-chain funds across channels as controlled to the same user.
+	 *  By parameterizing by the raw invoice bytes instead of the hash, we allow implementors of
+	 *  this trait to parse the invoice and make sure they're signing what they expect, rather than
+	 *  blindly signing the hash.
+	 * 
+	 *  The `hrp_bytes` are 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::ShutdownScript get_shutdown_scriptpubkey();
+	inline LDK::CResult_RecoverableSignatureNoneZ sign_invoice(struct LDKu8slice hrp_bytes, struct LDKCVec_U5Z invoice_data, enum LDKRecipient recipient);
 	/**
-	 *  Get a new set of Sign for per-channel secrets. These MUST be unique even if you
-	 *  restarted with some stale data!
+	 *  Sign a gossip message.
 	 * 
-	 *  This method must return a different value each time it is called.
+	 *  Note that if this fails, LDK may panic and the message will not be broadcast to the network
+	 *  or a possible channel counterparty. If LDK panics, the error should be resolved to allow the
+	 *  message to be broadcast, as otherwise it may prevent one from receiving funds over the
+	 *  corresponding channel.
 	 */
-	inline LDK::Sign get_channel_signer(bool inbound, uint64_t channel_value_satoshis);
+	inline LDK::CResult_SignatureNoneZ sign_gossip_message(struct LDKUnsignedGossipMessage msg);
+};
+class SignerProvider {
+private:
+	LDKSignerProvider self;
+public:
+	SignerProvider(const SignerProvider&) = delete;
+	SignerProvider(SignerProvider&& o) : self(o.self) { memset(&o, 0, sizeof(SignerProvider)); }
+	SignerProvider(LDKSignerProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignerProvider)); }
+	operator LDKSignerProvider() && { LDKSignerProvider res = self; memset(&self, 0, sizeof(LDKSignerProvider)); return res; }
+	~SignerProvider() { SignerProvider_free(self); }
+	SignerProvider& operator=(SignerProvider&& o) { SignerProvider_free(self); self = o.self; memset(&o, 0, sizeof(SignerProvider)); return *this; }
+	LDKSignerProvider* operator &() { return &self; }
+	LDKSignerProvider* operator ->() { return &self; }
+	const LDKSignerProvider* operator &() const { return &self; }
+	const LDKSignerProvider* operator ->() const { return &self; }
 	/**
-	 *  Gets a unique, cryptographically-secure, random 32 byte value. This is used for encrypting
-	 *  onion packets and for temporary channel IDs. There is no requirement that these be
-	 *  persisted anywhere, though they must be unique across restarts.
+	 *  Generates a unique `channel_keys_id` that can be used to obtain a [`Self::Signer`] through
+	 *  [`SignerProvider::derive_channel_signer`]. The `user_channel_id` is provided to allow
+	 *  implementations of [`SignerProvider`] to maintain a mapping between itself and the generated
+	 *  `channel_keys_id`.
 	 * 
 	 *  This method must return a different value each time it is called.
 	 */
-	inline LDKThirtyTwoBytes get_secure_random_bytes();
+	inline LDKThirtyTwoBytes generate_channel_keys_id(bool inbound, uint64_t channel_value_satoshis, struct LDKU128 user_channel_id);
+	/**
+	 *  Derives the private key material backing a `Signer`.
+	 * 
+	 *  To derive a new `Signer`, a fresh `channel_keys_id` should be obtained through
+	 *  [`SignerProvider::generate_channel_keys_id`]. Otherwise, an existing `Signer` can be
+	 *  re-derived from its `channel_keys_id`, which can be obtained through its trait method
+	 *  [`ChannelSigner::channel_keys_id`].
+	 */
+	inline LDK::WriteableEcdsaChannelSigner derive_channel_signer(uint64_t channel_value_satoshis, struct LDKThirtyTwoBytes channel_keys_id);
 	/**
-	 *  Reads a `Signer` for this `KeysInterface` from the given input stream.
+	 *  Reads a [`Signer`] for this [`SignerProvider`] from the given input stream.
 	 *  This is only called during deserialization of other objects which contain
-	 *  `Sign`-implementing objects (ie `ChannelMonitor`s and `ChannelManager`s).
+	 *  [`WriteableEcdsaChannelSigner`]-implementing objects (i.e., [`ChannelMonitor`]s and [`ChannelManager`]s).
 	 *  The bytes are exactly those which `<Self::Signer as Writeable>::write()` writes, and
 	 *  contain no versioning scheme. You may wish to include your own version prefix and ensure
 	 *  you've read all of the provided bytes to ensure no corruption occurred.
+	 * 
+	 *  This method is slowly being phased out -- it will only be called when reading objects
+	 *  written by LDK versions prior to 0.0.113.
+	 * 
+	 *  [`Signer`]: Self::Signer
+	 *  [`ChannelMonitor`]: crate::chain::channelmonitor::ChannelMonitor
+	 *  [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
 	 */
-	inline LDK::CResult_SignDecodeErrorZ read_chan_signer(struct LDKu8slice reader);
+	inline LDK::CResult_WriteableEcdsaChannelSignerDecodeErrorZ read_chan_signer(struct LDKu8slice reader);
 	/**
-	 *  Sign an invoice.
-	 *  By parameterizing by the raw invoice bytes instead of the hash, we allow implementors of
-	 *  this trait to parse the invoice and make sure they're signing what they expect, rather than
-	 *  blindly signing the hash.
-	 *  The hrp is ascii bytes, while the invoice data is base32.
+	 *  Get a script pubkey which we send funds to when claiming on-chain contestable outputs.
 	 * 
-	 *  The secret key used to sign the invoice is dependent on the [`Recipient`].
+	 *  This method should return a different value each time it is called, to avoid linking
+	 *  on-chain funds across channels as controlled to the same user.
 	 */
-	inline LDK::CResult_RecoverableSignatureNoneZ sign_invoice(struct LDKu8slice hrp_bytes, struct LDKCVec_u5Z invoice_data, enum LDKRecipient receipient);
+	inline LDK::CVec_u8Z get_destination_script();
 	/**
-	 *  Get secret key material as bytes for use in encrypting and decrypting inbound payment data.
-	 * 
-	 *  If the implementor of this trait supports [phantom node payments], then every node that is
-	 *  intended to be included in the phantom invoice route hints must return the same value from
-	 *  this method.
-	 * 
-	 *  This method must return the same value each time it is called.
+	 *  Get a script pubkey which we will send funds to when closing a channel.
 	 * 
-	 *  [phantom node payments]: PhantomKeysManager
+	 *  This method should return a different value each time it is called, to avoid linking
+	 *  on-chain funds across channels as controlled to the same user.
 	 */
-	inline LDKThirtyTwoBytes get_inbound_payment_key_material();
+	inline LDK::ShutdownScript get_shutdown_scriptpubkey();
 };
 class InMemorySigner {
 private:
@@ -1994,6 +2457,20 @@ public:
 	const LDKFilesystemPersister* operator &() const { return &self; }
 	const LDKFilesystemPersister* operator ->() const { return &self; }
 };
+class FailureCode {
+private:
+	LDKFailureCode self;
+public:
+	FailureCode(const FailureCode&) = delete;
+	FailureCode(FailureCode&& o) : self(o.self) { memset(&o, 0, sizeof(FailureCode)); }
+	FailureCode(LDKFailureCode&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFailureCode)); }
+	operator LDKFailureCode() && { LDKFailureCode res = self; memset(&self, 0, sizeof(LDKFailureCode)); return res; }
+	FailureCode& operator=(FailureCode&& o) { self = o.self; memset(&o, 0, sizeof(FailureCode)); return *this; }
+	LDKFailureCode* operator &() { return &self; }
+	LDKFailureCode* operator ->() { return &self; }
+	const LDKFailureCode* operator &() const { return &self; }
+	const LDKFailureCode* operator ->() const { return &self; }
+};
 class ChannelManager {
 private:
 	LDKChannelManager self;
@@ -2069,20 +2546,20 @@ public:
 	const LDKChannelDetails* operator &() const { return &self; }
 	const LDKChannelDetails* operator ->() const { return &self; }
 };
-class PaymentSendFailure {
+class RecentPaymentDetails {
 private:
-	LDKPaymentSendFailure self;
+	LDKRecentPaymentDetails self;
 public:
-	PaymentSendFailure(const PaymentSendFailure&) = delete;
-	PaymentSendFailure(PaymentSendFailure&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentSendFailure)); }
-	PaymentSendFailure(LDKPaymentSendFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentSendFailure)); }
-	operator LDKPaymentSendFailure() && { LDKPaymentSendFailure res = self; memset(&self, 0, sizeof(LDKPaymentSendFailure)); return res; }
-	~PaymentSendFailure() { PaymentSendFailure_free(self); }
-	PaymentSendFailure& operator=(PaymentSendFailure&& o) { PaymentSendFailure_free(self); self = o.self; memset(&o, 0, sizeof(PaymentSendFailure)); return *this; }
-	LDKPaymentSendFailure* operator &() { return &self; }
-	LDKPaymentSendFailure* operator ->() { return &self; }
-	const LDKPaymentSendFailure* operator &() const { return &self; }
-	const LDKPaymentSendFailure* operator ->() const { return &self; }
+	RecentPaymentDetails(const RecentPaymentDetails&) = delete;
+	RecentPaymentDetails(RecentPaymentDetails&& o) : self(o.self) { memset(&o, 0, sizeof(RecentPaymentDetails)); }
+	RecentPaymentDetails(LDKRecentPaymentDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRecentPaymentDetails)); }
+	operator LDKRecentPaymentDetails() && { LDKRecentPaymentDetails res = self; memset(&self, 0, sizeof(LDKRecentPaymentDetails)); return res; }
+	~RecentPaymentDetails() { RecentPaymentDetails_free(self); }
+	RecentPaymentDetails& operator=(RecentPaymentDetails&& o) { RecentPaymentDetails_free(self); self = o.self; memset(&o, 0, sizeof(RecentPaymentDetails)); return *this; }
+	LDKRecentPaymentDetails* operator &() { return &self; }
+	LDKRecentPaymentDetails* operator ->() { return &self; }
+	const LDKRecentPaymentDetails* operator &() const { return &self; }
+	const LDKRecentPaymentDetails* operator ->() const { return &self; }
 };
 class PhantomRouteHints {
 private:
@@ -2204,6 +2681,36 @@ 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 PrintableString {
+private:
+	LDKPrintableString self;
+public:
+	PrintableString(const PrintableString&) = delete;
+	PrintableString(PrintableString&& o) : self(o.self) { memset(&o, 0, sizeof(PrintableString)); }
+	PrintableString(LDKPrintableString&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPrintableString)); }
+	operator LDKPrintableString() && { LDKPrintableString res = self; memset(&self, 0, sizeof(LDKPrintableString)); return res; }
+	~PrintableString() { PrintableString_free(self); }
+	PrintableString& operator=(PrintableString&& o) { PrintableString_free(self); self = o.self; memset(&o, 0, sizeof(PrintableString)); return *this; }
+	LDKPrintableString* operator &() { return &self; }
+	LDKPrintableString* operator ->() { return &self; }
+	const LDKPrintableString* operator &() const { return &self; }
+	const LDKPrintableString* operator ->() const { return &self; }
+};
 class OutPoint {
 private:
 	LDKOutPoint self;
@@ -2264,101 +2771,9 @@ public:
 	 */
 	inline LDK::Str debug_str();
 };
-class InvoicePayer {
-private:
-	LDKInvoicePayer self;
-public:
-	InvoicePayer(const InvoicePayer&) = delete;
-	InvoicePayer(InvoicePayer&& o) : self(o.self) { memset(&o, 0, sizeof(InvoicePayer)); }
-	InvoicePayer(LDKInvoicePayer&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoicePayer)); }
-	operator LDKInvoicePayer() && { LDKInvoicePayer res = self; memset(&self, 0, sizeof(LDKInvoicePayer)); return res; }
-	~InvoicePayer() { InvoicePayer_free(self); }
-	InvoicePayer& operator=(InvoicePayer&& o) { InvoicePayer_free(self); self = o.self; memset(&o, 0, sizeof(InvoicePayer)); return *this; }
-	LDKInvoicePayer* operator &() { return &self; }
-	LDKInvoicePayer* operator ->() { return &self; }
-	const LDKInvoicePayer* operator &() const { return &self; }
-	const LDKInvoicePayer* operator ->() const { return &self; }
-};
-class Payer {
-private:
-	LDKPayer self;
-public:
-	Payer(const Payer&) = delete;
-	Payer(Payer&& o) : self(o.self) { memset(&o, 0, sizeof(Payer)); }
-	Payer(LDKPayer&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPayer)); }
-	operator LDKPayer() && { LDKPayer res = self; memset(&self, 0, sizeof(LDKPayer)); return res; }
-	~Payer() { Payer_free(self); }
-	Payer& operator=(Payer&& o) { Payer_free(self); self = o.self; memset(&o, 0, sizeof(Payer)); return *this; }
-	LDKPayer* operator &() { return &self; }
-	LDKPayer* operator ->() { return &self; }
-	const LDKPayer* operator &() const { return &self; }
-	const LDKPayer* operator ->() const { return &self; }
-	/**
-	 *  Returns the payer's node id.
-	 */
-	inline LDKPublicKey node_id();
-	/**
-	 *  Returns the payer's channels.
-	 */
-	inline LDK::CVec_ChannelDetailsZ first_hops();
-	/**
-	 *  Sends a payment over the Lightning Network using the given [`Route`].
-	 * 
-	 *  Note that payment_secret (or a relevant inner pointer) may be NULL or all-0s to represent None
-	 */
-	inline LDK::CResult_PaymentIdPaymentSendFailureZ send_payment(const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_hash, struct LDKThirtyTwoBytes payment_secret);
-	/**
-	 *  Sends a spontaneous payment over the Lightning Network using the given [`Route`].
-	 */
-	inline LDK::CResult_PaymentIdPaymentSendFailureZ send_spontaneous_payment(const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_preimage);
-	/**
-	 *  Retries a failed payment path for the [`PaymentId`] using the given [`Route`].
-	 */
-	inline LDK::CResult_NonePaymentSendFailureZ retry_payment(const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_id);
-	/**
-	 *  Signals that no further retries for the given payment will occur.
-	 */
-	inline void abandon_payment(struct LDKThirtyTwoBytes payment_id);
-};
-class Router {
+class PaymentError {
 private:
-	LDKRouter self;
-public:
-	Router(const Router&) = delete;
-	Router(Router&& o) : self(o.self) { memset(&o, 0, sizeof(Router)); }
-	Router(LDKRouter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouter)); }
-	operator LDKRouter() && { LDKRouter res = self; memset(&self, 0, sizeof(LDKRouter)); return res; }
-	~Router() { Router_free(self); }
-	Router& operator=(Router&& o) { Router_free(self); self = o.self; memset(&o, 0, sizeof(Router)); return *this; }
-	LDKRouter* operator &() { return &self; }
-	LDKRouter* operator ->() { return &self; }
-	const LDKRouter* operator &() const { return &self; }
-	const LDKRouter* operator ->() const { return &self; }
-	/**
-	 *  Finds a [`Route`] between `payer` and `payee` for a payment with the given values.
-	 * 
-	 *  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);
-};
-class Retry {
-private:
-	LDKRetry self;
-public:
-	Retry(const Retry&) = delete;
-	Retry(Retry&& o) : self(o.self) { memset(&o, 0, sizeof(Retry)); }
-	Retry(LDKRetry&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRetry)); }
-	operator LDKRetry() && { LDKRetry res = self; memset(&self, 0, sizeof(LDKRetry)); return res; }
-	~Retry() { Retry_free(self); }
-	Retry& operator=(Retry&& o) { Retry_free(self); self = o.self; memset(&o, 0, sizeof(Retry)); return *this; }
-	LDKRetry* operator &() { return &self; }
-	LDKRetry* operator ->() { return &self; }
-	const LDKRetry* operator &() const { return &self; }
-	const LDKRetry* operator ->() const { return &self; }
-};
-class PaymentError {
-private:
-	LDKPaymentError self;
+	LDKPaymentError self;
 public:
 	PaymentError(const PaymentError&) = delete;
 	PaymentError(PaymentError&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentError)); }
@@ -2371,144 +2786,521 @@ public:
 	const LDKPaymentError* operator &() const { return &self; }
 	const LDKPaymentError* operator ->() const { return &self; }
 };
-class ParseError {
+class ChannelMonitorUpdate {
 private:
-	LDKParseError self;
+	LDKChannelMonitorUpdate self;
 public:
-	ParseError(const ParseError&) = delete;
-	ParseError(ParseError&& o) : self(o.self) { memset(&o, 0, sizeof(ParseError)); }
-	ParseError(LDKParseError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKParseError)); }
-	operator LDKParseError() && { LDKParseError res = self; memset(&self, 0, sizeof(LDKParseError)); return res; }
-	~ParseError() { ParseError_free(self); }
-	ParseError& operator=(ParseError&& o) { ParseError_free(self); self = o.self; memset(&o, 0, sizeof(ParseError)); return *this; }
-	LDKParseError* operator &() { return &self; }
-	LDKParseError* operator ->() { return &self; }
-	const LDKParseError* operator &() const { return &self; }
-	const LDKParseError* operator ->() const { return &self; }
+	ChannelMonitorUpdate(const ChannelMonitorUpdate&) = delete;
+	ChannelMonitorUpdate(ChannelMonitorUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitorUpdate)); }
+	ChannelMonitorUpdate(LDKChannelMonitorUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitorUpdate)); }
+	operator LDKChannelMonitorUpdate() && { LDKChannelMonitorUpdate res = self; memset(&self, 0, sizeof(LDKChannelMonitorUpdate)); return res; }
+	~ChannelMonitorUpdate() { ChannelMonitorUpdate_free(self); }
+	ChannelMonitorUpdate& operator=(ChannelMonitorUpdate&& o) { ChannelMonitorUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMonitorUpdate)); return *this; }
+	LDKChannelMonitorUpdate* operator &() { return &self; }
+	LDKChannelMonitorUpdate* operator ->() { return &self; }
+	const LDKChannelMonitorUpdate* operator &() const { return &self; }
+	const LDKChannelMonitorUpdate* operator ->() const { return &self; }
 };
-class ParseOrSemanticError {
+class MonitorEvent {
 private:
-	LDKParseOrSemanticError self;
+	LDKMonitorEvent self;
 public:
-	ParseOrSemanticError(const ParseOrSemanticError&) = delete;
-	ParseOrSemanticError(ParseOrSemanticError&& o) : self(o.self) { memset(&o, 0, sizeof(ParseOrSemanticError)); }
-	ParseOrSemanticError(LDKParseOrSemanticError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKParseOrSemanticError)); }
-	operator LDKParseOrSemanticError() && { LDKParseOrSemanticError res = self; memset(&self, 0, sizeof(LDKParseOrSemanticError)); return res; }
-	~ParseOrSemanticError() { ParseOrSemanticError_free(self); }
-	ParseOrSemanticError& operator=(ParseOrSemanticError&& o) { ParseOrSemanticError_free(self); self = o.self; memset(&o, 0, sizeof(ParseOrSemanticError)); return *this; }
-	LDKParseOrSemanticError* operator &() { return &self; }
-	LDKParseOrSemanticError* operator ->() { return &self; }
-	const LDKParseOrSemanticError* operator &() const { return &self; }
-	const LDKParseOrSemanticError* operator ->() const { return &self; }
+	MonitorEvent(const MonitorEvent&) = delete;
+	MonitorEvent(MonitorEvent&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorEvent)); }
+	MonitorEvent(LDKMonitorEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorEvent)); }
+	operator LDKMonitorEvent() && { LDKMonitorEvent res = self; memset(&self, 0, sizeof(LDKMonitorEvent)); return res; }
+	~MonitorEvent() { MonitorEvent_free(self); }
+	MonitorEvent& operator=(MonitorEvent&& o) { MonitorEvent_free(self); self = o.self; memset(&o, 0, sizeof(MonitorEvent)); return *this; }
+	LDKMonitorEvent* operator &() { return &self; }
+	LDKMonitorEvent* operator ->() { return &self; }
+	const LDKMonitorEvent* operator &() const { return &self; }
+	const LDKMonitorEvent* operator ->() const { return &self; }
 };
-class Invoice {
+class HTLCUpdate {
 private:
-	LDKInvoice self;
+	LDKHTLCUpdate self;
 public:
-	Invoice(const Invoice&) = delete;
-	Invoice(Invoice&& o) : self(o.self) { memset(&o, 0, sizeof(Invoice)); }
-	Invoice(LDKInvoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoice)); }
-	operator LDKInvoice() && { LDKInvoice res = self; memset(&self, 0, sizeof(LDKInvoice)); return res; }
-	~Invoice() { Invoice_free(self); }
-	Invoice& operator=(Invoice&& o) { Invoice_free(self); self = o.self; memset(&o, 0, sizeof(Invoice)); return *this; }
-	LDKInvoice* operator &() { return &self; }
-	LDKInvoice* operator ->() { return &self; }
-	const LDKInvoice* operator &() const { return &self; }
-	const LDKInvoice* operator ->() const { return &self; }
+	HTLCUpdate(const HTLCUpdate&) = delete;
+	HTLCUpdate(HTLCUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCUpdate)); }
+	HTLCUpdate(LDKHTLCUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCUpdate)); }
+	operator LDKHTLCUpdate() && { LDKHTLCUpdate res = self; memset(&self, 0, sizeof(LDKHTLCUpdate)); return res; }
+	~HTLCUpdate() { HTLCUpdate_free(self); }
+	HTLCUpdate& operator=(HTLCUpdate&& o) { HTLCUpdate_free(self); self = o.self; memset(&o, 0, sizeof(HTLCUpdate)); return *this; }
+	LDKHTLCUpdate* operator &() { return &self; }
+	LDKHTLCUpdate* operator ->() { return &self; }
+	const LDKHTLCUpdate* operator &() const { return &self; }
+	const LDKHTLCUpdate* operator ->() const { return &self; }
 };
-class SignedRawInvoice {
+class Balance {
 private:
-	LDKSignedRawInvoice self;
+	LDKBalance self;
 public:
-	SignedRawInvoice(const SignedRawInvoice&) = delete;
-	SignedRawInvoice(SignedRawInvoice&& o) : self(o.self) { memset(&o, 0, sizeof(SignedRawInvoice)); }
-	SignedRawInvoice(LDKSignedRawInvoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignedRawInvoice)); }
-	operator LDKSignedRawInvoice() && { LDKSignedRawInvoice res = self; memset(&self, 0, sizeof(LDKSignedRawInvoice)); return res; }
-	~SignedRawInvoice() { SignedRawInvoice_free(self); }
-	SignedRawInvoice& operator=(SignedRawInvoice&& o) { SignedRawInvoice_free(self); self = o.self; memset(&o, 0, sizeof(SignedRawInvoice)); return *this; }
-	LDKSignedRawInvoice* operator &() { return &self; }
-	LDKSignedRawInvoice* operator ->() { return &self; }
-	const LDKSignedRawInvoice* operator &() const { return &self; }
-	const LDKSignedRawInvoice* operator ->() const { return &self; }
+	Balance(const Balance&) = delete;
+	Balance(Balance&& o) : self(o.self) { memset(&o, 0, sizeof(Balance)); }
+	Balance(LDKBalance&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBalance)); }
+	operator LDKBalance() && { LDKBalance res = self; memset(&self, 0, sizeof(LDKBalance)); return res; }
+	~Balance() { Balance_free(self); }
+	Balance& operator=(Balance&& o) { Balance_free(self); self = o.self; memset(&o, 0, sizeof(Balance)); return *this; }
+	LDKBalance* operator &() { return &self; }
+	LDKBalance* operator ->() { return &self; }
+	const LDKBalance* operator &() const { return &self; }
+	const LDKBalance* operator ->() const { return &self; }
 };
-class RawInvoice {
+class ChannelMonitor {
 private:
-	LDKRawInvoice self;
+	LDKChannelMonitor self;
 public:
-	RawInvoice(const RawInvoice&) = delete;
-	RawInvoice(RawInvoice&& o) : self(o.self) { memset(&o, 0, sizeof(RawInvoice)); }
-	RawInvoice(LDKRawInvoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRawInvoice)); }
-	operator LDKRawInvoice() && { LDKRawInvoice res = self; memset(&self, 0, sizeof(LDKRawInvoice)); return res; }
-	~RawInvoice() { RawInvoice_free(self); }
-	RawInvoice& operator=(RawInvoice&& o) { RawInvoice_free(self); self = o.self; memset(&o, 0, sizeof(RawInvoice)); return *this; }
-	LDKRawInvoice* operator &() { return &self; }
-	LDKRawInvoice* operator ->() { return &self; }
-	const LDKRawInvoice* operator &() const { return &self; }
-	const LDKRawInvoice* operator ->() const { return &self; }
+	ChannelMonitor(const ChannelMonitor&) = delete;
+	ChannelMonitor(ChannelMonitor&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitor)); }
+	ChannelMonitor(LDKChannelMonitor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitor)); }
+	operator LDKChannelMonitor() && { LDKChannelMonitor res = self; memset(&self, 0, sizeof(LDKChannelMonitor)); return res; }
+	~ChannelMonitor() { ChannelMonitor_free(self); }
+	ChannelMonitor& operator=(ChannelMonitor&& o) { ChannelMonitor_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMonitor)); return *this; }
+	LDKChannelMonitor* operator &() { return &self; }
+	LDKChannelMonitor* operator ->() { return &self; }
+	const LDKChannelMonitor* operator &() const { return &self; }
+	const LDKChannelMonitor* operator ->() const { return &self; }
 };
-class RawDataPart {
+class ExpandedKey {
 private:
-	LDKRawDataPart self;
+	LDKExpandedKey self;
 public:
-	RawDataPart(const RawDataPart&) = delete;
-	RawDataPart(RawDataPart&& o) : self(o.self) { memset(&o, 0, sizeof(RawDataPart)); }
-	RawDataPart(LDKRawDataPart&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRawDataPart)); }
-	operator LDKRawDataPart() && { LDKRawDataPart res = self; memset(&self, 0, sizeof(LDKRawDataPart)); return res; }
-	~RawDataPart() { RawDataPart_free(self); }
-	RawDataPart& operator=(RawDataPart&& o) { RawDataPart_free(self); self = o.self; memset(&o, 0, sizeof(RawDataPart)); return *this; }
-	LDKRawDataPart* operator &() { return &self; }
-	LDKRawDataPart* operator ->() { return &self; }
-	const LDKRawDataPart* operator &() const { return &self; }
-	const LDKRawDataPart* operator ->() const { return &self; }
+	ExpandedKey(const ExpandedKey&) = delete;
+	ExpandedKey(ExpandedKey&& o) : self(o.self) { memset(&o, 0, sizeof(ExpandedKey)); }
+	ExpandedKey(LDKExpandedKey&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKExpandedKey)); }
+	operator LDKExpandedKey() && { LDKExpandedKey res = self; memset(&self, 0, sizeof(LDKExpandedKey)); return res; }
+	~ExpandedKey() { ExpandedKey_free(self); }
+	ExpandedKey& operator=(ExpandedKey&& o) { ExpandedKey_free(self); self = o.self; memset(&o, 0, sizeof(ExpandedKey)); return *this; }
+	LDKExpandedKey* operator &() { return &self; }
+	LDKExpandedKey* operator ->() { return &self; }
+	const LDKExpandedKey* operator &() const { return &self; }
+	const LDKExpandedKey* operator ->() const { return &self; }
 };
-class PositiveTimestamp {
+class CustomMessageHandler {
 private:
-	LDKPositiveTimestamp self;
+	LDKCustomMessageHandler self;
 public:
-	PositiveTimestamp(const PositiveTimestamp&) = delete;
-	PositiveTimestamp(PositiveTimestamp&& o) : self(o.self) { memset(&o, 0, sizeof(PositiveTimestamp)); }
-	PositiveTimestamp(LDKPositiveTimestamp&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPositiveTimestamp)); }
-	operator LDKPositiveTimestamp() && { LDKPositiveTimestamp res = self; memset(&self, 0, sizeof(LDKPositiveTimestamp)); return res; }
-	~PositiveTimestamp() { PositiveTimestamp_free(self); }
-	PositiveTimestamp& operator=(PositiveTimestamp&& o) { PositiveTimestamp_free(self); self = o.self; memset(&o, 0, sizeof(PositiveTimestamp)); return *this; }
-	LDKPositiveTimestamp* operator &() { return &self; }
-	LDKPositiveTimestamp* operator ->() { return &self; }
-	const LDKPositiveTimestamp* operator &() const { return &self; }
-	const LDKPositiveTimestamp* operator ->() const { return &self; }
+	CustomMessageHandler(const CustomMessageHandler&) = delete;
+	CustomMessageHandler(CustomMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(CustomMessageHandler)); }
+	CustomMessageHandler(LDKCustomMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCustomMessageHandler)); }
+	operator LDKCustomMessageHandler() && { LDKCustomMessageHandler res = self; memset(&self, 0, sizeof(LDKCustomMessageHandler)); return res; }
+	~CustomMessageHandler() { CustomMessageHandler_free(self); }
+	CustomMessageHandler& operator=(CustomMessageHandler&& o) { CustomMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(CustomMessageHandler)); return *this; }
+	LDKCustomMessageHandler* operator &() { return &self; }
+	LDKCustomMessageHandler* operator ->() { return &self; }
+	const LDKCustomMessageHandler* operator &() const { return &self; }
+	const LDKCustomMessageHandler* operator ->() const { return &self; }
+	/**
+	 *  Handles the given message sent from `sender_node_id`, possibly producing messages for
+	 *  [`CustomMessageHandler::get_and_clear_pending_msg`] to return and thus for [`PeerManager`]
+	 *  to send.
+	 */
+	inline LDK::CResult_NoneLightningErrorZ handle_custom_message(struct LDKType msg, struct LDKPublicKey sender_node_id);
+	/**
+	 *  Returns the list of pending messages that were generated by the handler, clearing the list
+	 *  in the process. Each message is paired with the node id of the intended recipient. If no
+	 *  connection to the node exists, then the message is simply not sent.
+	 */
+	inline LDK::CVec_C2Tuple_PublicKeyTypeZZ get_and_clear_pending_msg();
 };
-class SiPrefix {
+class IgnoringMessageHandler {
 private:
-	LDKSiPrefix self;
+	LDKIgnoringMessageHandler self;
 public:
-	SiPrefix(const SiPrefix&) = delete;
-	SiPrefix(SiPrefix&& o) : self(o.self) { memset(&o, 0, sizeof(SiPrefix)); }
-	SiPrefix(LDKSiPrefix&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSiPrefix)); }
-	operator LDKSiPrefix() && { LDKSiPrefix res = self; memset(&self, 0, sizeof(LDKSiPrefix)); return res; }
-	SiPrefix& operator=(SiPrefix&& o) { self = o.self; memset(&o, 0, sizeof(SiPrefix)); return *this; }
-	LDKSiPrefix* operator &() { return &self; }
-	LDKSiPrefix* operator ->() { return &self; }
-	const LDKSiPrefix* operator &() const { return &self; }
-	const LDKSiPrefix* operator ->() const { return &self; }
+	IgnoringMessageHandler(const IgnoringMessageHandler&) = delete;
+	IgnoringMessageHandler(IgnoringMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(IgnoringMessageHandler)); }
+	IgnoringMessageHandler(LDKIgnoringMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKIgnoringMessageHandler)); }
+	operator LDKIgnoringMessageHandler() && { LDKIgnoringMessageHandler res = self; memset(&self, 0, sizeof(LDKIgnoringMessageHandler)); return res; }
+	~IgnoringMessageHandler() { IgnoringMessageHandler_free(self); }
+	IgnoringMessageHandler& operator=(IgnoringMessageHandler&& o) { IgnoringMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(IgnoringMessageHandler)); return *this; }
+	LDKIgnoringMessageHandler* operator &() { return &self; }
+	LDKIgnoringMessageHandler* operator ->() { return &self; }
+	const LDKIgnoringMessageHandler* operator &() const { return &self; }
+	const LDKIgnoringMessageHandler* operator ->() const { return &self; }
 };
-class Currency {
+class ErroringMessageHandler {
 private:
-	LDKCurrency self;
+	LDKErroringMessageHandler self;
 public:
-	Currency(const Currency&) = delete;
-	Currency(Currency&& o) : self(o.self) { memset(&o, 0, sizeof(Currency)); }
-	Currency(LDKCurrency&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCurrency)); }
-	operator LDKCurrency() && { LDKCurrency res = self; memset(&self, 0, sizeof(LDKCurrency)); return res; }
-	Currency& operator=(Currency&& o) { self = o.self; memset(&o, 0, sizeof(Currency)); return *this; }
-	LDKCurrency* operator &() { return &self; }
-	LDKCurrency* operator ->() { return &self; }
-	const LDKCurrency* operator &() const { return &self; }
-	const LDKCurrency* operator ->() const { return &self; }
+	ErroringMessageHandler(const ErroringMessageHandler&) = delete;
+	ErroringMessageHandler(ErroringMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(ErroringMessageHandler)); }
+	ErroringMessageHandler(LDKErroringMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErroringMessageHandler)); }
+	operator LDKErroringMessageHandler() && { LDKErroringMessageHandler res = self; memset(&self, 0, sizeof(LDKErroringMessageHandler)); return res; }
+	~ErroringMessageHandler() { ErroringMessageHandler_free(self); }
+	ErroringMessageHandler& operator=(ErroringMessageHandler&& o) { ErroringMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(ErroringMessageHandler)); return *this; }
+	LDKErroringMessageHandler* operator &() { return &self; }
+	LDKErroringMessageHandler* operator ->() { return &self; }
+	const LDKErroringMessageHandler* operator &() const { return &self; }
+	const LDKErroringMessageHandler* operator ->() const { return &self; }
 };
-class Sha256 {
+class MessageHandler {
 private:
-	LDKSha256 self;
+	LDKMessageHandler self;
 public:
-	Sha256(const Sha256&) = delete;
+	MessageHandler(const MessageHandler&) = delete;
+	MessageHandler(MessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(MessageHandler)); }
+	MessageHandler(LDKMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageHandler)); }
+	operator LDKMessageHandler() && { LDKMessageHandler res = self; memset(&self, 0, sizeof(LDKMessageHandler)); return res; }
+	~MessageHandler() { MessageHandler_free(self); }
+	MessageHandler& operator=(MessageHandler&& o) { MessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(MessageHandler)); return *this; }
+	LDKMessageHandler* operator &() { return &self; }
+	LDKMessageHandler* operator ->() { return &self; }
+	const LDKMessageHandler* operator &() const { return &self; }
+	const LDKMessageHandler* operator ->() const { return &self; }
+};
+class SocketDescriptor {
+private:
+	LDKSocketDescriptor self;
+public:
+	SocketDescriptor(const SocketDescriptor&) = delete;
+	SocketDescriptor(SocketDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(SocketDescriptor)); }
+	SocketDescriptor(LDKSocketDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSocketDescriptor)); }
+	operator LDKSocketDescriptor() && { LDKSocketDescriptor res = self; memset(&self, 0, sizeof(LDKSocketDescriptor)); return res; }
+	~SocketDescriptor() { SocketDescriptor_free(self); }
+	SocketDescriptor& operator=(SocketDescriptor&& o) { SocketDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(SocketDescriptor)); return *this; }
+	LDKSocketDescriptor* operator &() { return &self; }
+	LDKSocketDescriptor* operator ->() { return &self; }
+	const LDKSocketDescriptor* operator &() const { return &self; }
+	const LDKSocketDescriptor* operator ->() const { return &self; }
+	/**
+	 *  Attempts to send some data from the given slice to the peer.
+	 * 
+	 *  Returns the amount of data which was sent, possibly 0 if the socket has since disconnected.
+	 *  Note that in the disconnected case, [`PeerManager::socket_disconnected`] must still be
+	 *  called and further write attempts may occur until that time.
+	 * 
+	 *  If the returned size is smaller than `data.len()`, a
+	 *  [`PeerManager::write_buffer_space_avail`] call must be made the next time more data can be
+	 *  written. Additionally, until a `send_data` event completes fully, no further
+	 *  [`PeerManager::read_event`] calls should be made for the same peer! Because this is to
+	 *  prevent denial-of-service issues, you should not read or buffer any data from the socket
+	 *  until then.
+	 * 
+	 *  If a [`PeerManager::read_event`] call on this descriptor had previously returned true
+	 *  (indicating that read events should be paused to prevent DoS in the send buffer),
+	 *  `resume_read` may be set indicating that read events on this descriptor should resume. A
+	 *  `resume_read` of false carries no meaning, and should not cause any action.
+	 */
+	inline uintptr_t send_data(struct LDKu8slice data, bool resume_read);
+	/**
+	 *  Disconnect the socket pointed to by this SocketDescriptor.
+	 * 
+	 *  You do *not* need to call [`PeerManager::socket_disconnected`] with this socket after this
+	 *  call (doing so is a noop).
+	 */
+	inline void disconnect_socket();
+	/** Checks if two objects are equal given this object's this_arg pointer and another object. */
+	inline bool eq(const struct LDKSocketDescriptor *NONNULL_PTR other_arg);
+	/**
+	 * Calculate a succinct non-cryptographic hash for an object given its this_arg pointer.
+	 * This is used, for example, for inclusion of this object in a hash map.
+	 */
+	inline uint64_t hash();
+};
+class PeerHandleError {
+private:
+	LDKPeerHandleError self;
+public:
+	PeerHandleError(const PeerHandleError&) = delete;
+	PeerHandleError(PeerHandleError&& o) : self(o.self) { memset(&o, 0, sizeof(PeerHandleError)); }
+	PeerHandleError(LDKPeerHandleError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeerHandleError)); }
+	operator LDKPeerHandleError() && { LDKPeerHandleError res = self; memset(&self, 0, sizeof(LDKPeerHandleError)); return res; }
+	~PeerHandleError() { PeerHandleError_free(self); }
+	PeerHandleError& operator=(PeerHandleError&& o) { PeerHandleError_free(self); self = o.self; memset(&o, 0, sizeof(PeerHandleError)); return *this; }
+	LDKPeerHandleError* operator &() { return &self; }
+	LDKPeerHandleError* operator ->() { return &self; }
+	const LDKPeerHandleError* operator &() const { return &self; }
+	const LDKPeerHandleError* operator ->() const { return &self; }
+};
+class PeerManager {
+private:
+	LDKPeerManager self;
+public:
+	PeerManager(const PeerManager&) = delete;
+	PeerManager(PeerManager&& o) : self(o.self) { memset(&o, 0, sizeof(PeerManager)); }
+	PeerManager(LDKPeerManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeerManager)); }
+	operator LDKPeerManager() && { LDKPeerManager res = self; memset(&self, 0, sizeof(LDKPeerManager)); return res; }
+	~PeerManager() { PeerManager_free(self); }
+	PeerManager& operator=(PeerManager&& o) { PeerManager_free(self); self = o.self; memset(&o, 0, sizeof(PeerManager)); return *this; }
+	LDKPeerManager* operator &() { return &self; }
+	LDKPeerManager* operator ->() { return &self; }
+	const LDKPeerManager* operator &() const { return &self; }
+	const LDKPeerManager* operator ->() const { return &self; }
+};
+class UtxoLookupError {
+private:
+	LDKUtxoLookupError self;
+public:
+	UtxoLookupError(const UtxoLookupError&) = delete;
+	UtxoLookupError(UtxoLookupError&& o) : self(o.self) { memset(&o, 0, sizeof(UtxoLookupError)); }
+	UtxoLookupError(LDKUtxoLookupError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUtxoLookupError)); }
+	operator LDKUtxoLookupError() && { LDKUtxoLookupError res = self; memset(&self, 0, sizeof(LDKUtxoLookupError)); return res; }
+	UtxoLookupError& operator=(UtxoLookupError&& o) { self = o.self; memset(&o, 0, sizeof(UtxoLookupError)); return *this; }
+	LDKUtxoLookupError* operator &() { return &self; }
+	LDKUtxoLookupError* operator ->() { return &self; }
+	const LDKUtxoLookupError* operator &() const { return &self; }
+	const LDKUtxoLookupError* operator ->() const { return &self; }
+};
+class UtxoResult {
+private:
+	LDKUtxoResult self;
+public:
+	UtxoResult(const UtxoResult&) = delete;
+	UtxoResult(UtxoResult&& o) : self(o.self) { memset(&o, 0, sizeof(UtxoResult)); }
+	UtxoResult(LDKUtxoResult&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUtxoResult)); }
+	operator LDKUtxoResult() && { LDKUtxoResult res = self; memset(&self, 0, sizeof(LDKUtxoResult)); return res; }
+	~UtxoResult() { UtxoResult_free(self); }
+	UtxoResult& operator=(UtxoResult&& o) { UtxoResult_free(self); self = o.self; memset(&o, 0, sizeof(UtxoResult)); return *this; }
+	LDKUtxoResult* operator &() { return &self; }
+	LDKUtxoResult* operator ->() { return &self; }
+	const LDKUtxoResult* operator &() const { return &self; }
+	const LDKUtxoResult* operator ->() const { return &self; }
+};
+class UtxoLookup {
+private:
+	LDKUtxoLookup self;
+public:
+	UtxoLookup(const UtxoLookup&) = delete;
+	UtxoLookup(UtxoLookup&& o) : self(o.self) { memset(&o, 0, sizeof(UtxoLookup)); }
+	UtxoLookup(LDKUtxoLookup&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUtxoLookup)); }
+	operator LDKUtxoLookup() && { LDKUtxoLookup res = self; memset(&self, 0, sizeof(LDKUtxoLookup)); return res; }
+	~UtxoLookup() { UtxoLookup_free(self); }
+	UtxoLookup& operator=(UtxoLookup&& o) { UtxoLookup_free(self); self = o.self; memset(&o, 0, sizeof(UtxoLookup)); return *this; }
+	LDKUtxoLookup* operator &() { return &self; }
+	LDKUtxoLookup* operator ->() { return &self; }
+	const LDKUtxoLookup* operator &() const { return &self; }
+	const LDKUtxoLookup* operator ->() const { return &self; }
+	/**
+	 *  Returns the transaction output of a funding transaction encoded by [`short_channel_id`].
+	 *  Returns an error if `genesis_hash` is for a different chain or if such a transaction output
+	 *  is unknown.
+	 * 
+	 *  [`short_channel_id`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#definition-of-short_channel_id
+	 */
+	inline LDK::UtxoResult get_utxo(const uint8_t (*genesis_hash)[32], uint64_t short_channel_id);
+};
+class UtxoFuture {
+private:
+	LDKUtxoFuture self;
+public:
+	UtxoFuture(const UtxoFuture&) = delete;
+	UtxoFuture(UtxoFuture&& o) : self(o.self) { memset(&o, 0, sizeof(UtxoFuture)); }
+	UtxoFuture(LDKUtxoFuture&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUtxoFuture)); }
+	operator LDKUtxoFuture() && { LDKUtxoFuture res = self; memset(&self, 0, sizeof(LDKUtxoFuture)); return res; }
+	~UtxoFuture() { UtxoFuture_free(self); }
+	UtxoFuture& operator=(UtxoFuture&& o) { UtxoFuture_free(self); self = o.self; memset(&o, 0, sizeof(UtxoFuture)); return *this; }
+	LDKUtxoFuture* operator &() { return &self; }
+	LDKUtxoFuture* operator ->() { return &self; }
+	const LDKUtxoFuture* operator &() const { return &self; }
+	const LDKUtxoFuture* 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 ParseError {
+private:
+	LDKParseError self;
+public:
+	ParseError(const ParseError&) = delete;
+	ParseError(ParseError&& o) : self(o.self) { memset(&o, 0, sizeof(ParseError)); }
+	ParseError(LDKParseError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKParseError)); }
+	operator LDKParseError() && { LDKParseError res = self; memset(&self, 0, sizeof(LDKParseError)); return res; }
+	~ParseError() { ParseError_free(self); }
+	ParseError& operator=(ParseError&& o) { ParseError_free(self); self = o.self; memset(&o, 0, sizeof(ParseError)); return *this; }
+	LDKParseError* operator &() { return &self; }
+	LDKParseError* operator ->() { return &self; }
+	const LDKParseError* operator &() const { return &self; }
+	const LDKParseError* operator ->() const { return &self; }
+};
+class ParseOrSemanticError {
+private:
+	LDKParseOrSemanticError self;
+public:
+	ParseOrSemanticError(const ParseOrSemanticError&) = delete;
+	ParseOrSemanticError(ParseOrSemanticError&& o) : self(o.self) { memset(&o, 0, sizeof(ParseOrSemanticError)); }
+	ParseOrSemanticError(LDKParseOrSemanticError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKParseOrSemanticError)); }
+	operator LDKParseOrSemanticError() && { LDKParseOrSemanticError res = self; memset(&self, 0, sizeof(LDKParseOrSemanticError)); return res; }
+	~ParseOrSemanticError() { ParseOrSemanticError_free(self); }
+	ParseOrSemanticError& operator=(ParseOrSemanticError&& o) { ParseOrSemanticError_free(self); self = o.self; memset(&o, 0, sizeof(ParseOrSemanticError)); return *this; }
+	LDKParseOrSemanticError* operator &() { return &self; }
+	LDKParseOrSemanticError* operator ->() { return &self; }
+	const LDKParseOrSemanticError* operator &() const { return &self; }
+	const LDKParseOrSemanticError* operator ->() const { return &self; }
+};
+class Invoice {
+private:
+	LDKInvoice self;
+public:
+	Invoice(const Invoice&) = delete;
+	Invoice(Invoice&& o) : self(o.self) { memset(&o, 0, sizeof(Invoice)); }
+	Invoice(LDKInvoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoice)); }
+	operator LDKInvoice() && { LDKInvoice res = self; memset(&self, 0, sizeof(LDKInvoice)); return res; }
+	~Invoice() { Invoice_free(self); }
+	Invoice& operator=(Invoice&& o) { Invoice_free(self); self = o.self; memset(&o, 0, sizeof(Invoice)); return *this; }
+	LDKInvoice* operator &() { return &self; }
+	LDKInvoice* operator ->() { return &self; }
+	const LDKInvoice* operator &() const { return &self; }
+	const LDKInvoice* operator ->() const { return &self; }
+};
+class SignedRawInvoice {
+private:
+	LDKSignedRawInvoice self;
+public:
+	SignedRawInvoice(const SignedRawInvoice&) = delete;
+	SignedRawInvoice(SignedRawInvoice&& o) : self(o.self) { memset(&o, 0, sizeof(SignedRawInvoice)); }
+	SignedRawInvoice(LDKSignedRawInvoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignedRawInvoice)); }
+	operator LDKSignedRawInvoice() && { LDKSignedRawInvoice res = self; memset(&self, 0, sizeof(LDKSignedRawInvoice)); return res; }
+	~SignedRawInvoice() { SignedRawInvoice_free(self); }
+	SignedRawInvoice& operator=(SignedRawInvoice&& o) { SignedRawInvoice_free(self); self = o.self; memset(&o, 0, sizeof(SignedRawInvoice)); return *this; }
+	LDKSignedRawInvoice* operator &() { return &self; }
+	LDKSignedRawInvoice* operator ->() { return &self; }
+	const LDKSignedRawInvoice* operator &() const { return &self; }
+	const LDKSignedRawInvoice* operator ->() const { return &self; }
+};
+class RawInvoice {
+private:
+	LDKRawInvoice self;
+public:
+	RawInvoice(const RawInvoice&) = delete;
+	RawInvoice(RawInvoice&& o) : self(o.self) { memset(&o, 0, sizeof(RawInvoice)); }
+	RawInvoice(LDKRawInvoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRawInvoice)); }
+	operator LDKRawInvoice() && { LDKRawInvoice res = self; memset(&self, 0, sizeof(LDKRawInvoice)); return res; }
+	~RawInvoice() { RawInvoice_free(self); }
+	RawInvoice& operator=(RawInvoice&& o) { RawInvoice_free(self); self = o.self; memset(&o, 0, sizeof(RawInvoice)); return *this; }
+	LDKRawInvoice* operator &() { return &self; }
+	LDKRawInvoice* operator ->() { return &self; }
+	const LDKRawInvoice* operator &() const { return &self; }
+	const LDKRawInvoice* operator ->() const { return &self; }
+};
+class RawDataPart {
+private:
+	LDKRawDataPart self;
+public:
+	RawDataPart(const RawDataPart&) = delete;
+	RawDataPart(RawDataPart&& o) : self(o.self) { memset(&o, 0, sizeof(RawDataPart)); }
+	RawDataPart(LDKRawDataPart&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRawDataPart)); }
+	operator LDKRawDataPart() && { LDKRawDataPart res = self; memset(&self, 0, sizeof(LDKRawDataPart)); return res; }
+	~RawDataPart() { RawDataPart_free(self); }
+	RawDataPart& operator=(RawDataPart&& o) { RawDataPart_free(self); self = o.self; memset(&o, 0, sizeof(RawDataPart)); return *this; }
+	LDKRawDataPart* operator &() { return &self; }
+	LDKRawDataPart* operator ->() { return &self; }
+	const LDKRawDataPart* operator &() const { return &self; }
+	const LDKRawDataPart* operator ->() const { return &self; }
+};
+class PositiveTimestamp {
+private:
+	LDKPositiveTimestamp self;
+public:
+	PositiveTimestamp(const PositiveTimestamp&) = delete;
+	PositiveTimestamp(PositiveTimestamp&& o) : self(o.self) { memset(&o, 0, sizeof(PositiveTimestamp)); }
+	PositiveTimestamp(LDKPositiveTimestamp&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPositiveTimestamp)); }
+	operator LDKPositiveTimestamp() && { LDKPositiveTimestamp res = self; memset(&self, 0, sizeof(LDKPositiveTimestamp)); return res; }
+	~PositiveTimestamp() { PositiveTimestamp_free(self); }
+	PositiveTimestamp& operator=(PositiveTimestamp&& o) { PositiveTimestamp_free(self); self = o.self; memset(&o, 0, sizeof(PositiveTimestamp)); return *this; }
+	LDKPositiveTimestamp* operator &() { return &self; }
+	LDKPositiveTimestamp* operator ->() { return &self; }
+	const LDKPositiveTimestamp* operator &() const { return &self; }
+	const LDKPositiveTimestamp* operator ->() const { return &self; }
+};
+class SiPrefix {
+private:
+	LDKSiPrefix self;
+public:
+	SiPrefix(const SiPrefix&) = delete;
+	SiPrefix(SiPrefix&& o) : self(o.self) { memset(&o, 0, sizeof(SiPrefix)); }
+	SiPrefix(LDKSiPrefix&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSiPrefix)); }
+	operator LDKSiPrefix() && { LDKSiPrefix res = self; memset(&self, 0, sizeof(LDKSiPrefix)); return res; }
+	SiPrefix& operator=(SiPrefix&& o) { self = o.self; memset(&o, 0, sizeof(SiPrefix)); return *this; }
+	LDKSiPrefix* operator &() { return &self; }
+	LDKSiPrefix* operator ->() { return &self; }
+	const LDKSiPrefix* operator &() const { return &self; }
+	const LDKSiPrefix* operator ->() const { return &self; }
+};
+class Currency {
+private:
+	LDKCurrency self;
+public:
+	Currency(const Currency&) = delete;
+	Currency(Currency&& o) : self(o.self) { memset(&o, 0, sizeof(Currency)); }
+	Currency(LDKCurrency&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCurrency)); }
+	operator LDKCurrency() && { LDKCurrency res = self; memset(&self, 0, sizeof(LDKCurrency)); return res; }
+	Currency& operator=(Currency&& o) { self = o.self; memset(&o, 0, sizeof(Currency)); return *this; }
+	LDKCurrency* operator &() { return &self; }
+	LDKCurrency* operator ->() { return &self; }
+	const LDKCurrency* operator &() const { return &self; }
+	const LDKCurrency* operator ->() const { return &self; }
+};
+class Sha256 {
+private:
+	LDKSha256 self;
+public:
+	Sha256(const Sha256&) = delete;
 	Sha256(Sha256&& o) : self(o.self) { memset(&o, 0, sizeof(Sha256)); }
 	Sha256(LDKSha256&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSha256)); }
 	operator LDKSha256() && { LDKSha256 res = self; memset(&self, 0, sizeof(LDKSha256)); return res; }
@@ -2564,20 +3356,20 @@ public:
 	const LDKExpiryTime* operator &() const { return &self; }
 	const LDKExpiryTime* operator ->() const { return &self; }
 };
-class MinFinalCltvExpiry {
+class MinFinalCltvExpiryDelta {
 private:
-	LDKMinFinalCltvExpiry self;
+	LDKMinFinalCltvExpiryDelta self;
 public:
-	MinFinalCltvExpiry(const MinFinalCltvExpiry&) = delete;
-	MinFinalCltvExpiry(MinFinalCltvExpiry&& o) : self(o.self) { memset(&o, 0, sizeof(MinFinalCltvExpiry)); }
-	MinFinalCltvExpiry(LDKMinFinalCltvExpiry&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMinFinalCltvExpiry)); }
-	operator LDKMinFinalCltvExpiry() && { LDKMinFinalCltvExpiry res = self; memset(&self, 0, sizeof(LDKMinFinalCltvExpiry)); return res; }
-	~MinFinalCltvExpiry() { MinFinalCltvExpiry_free(self); }
-	MinFinalCltvExpiry& operator=(MinFinalCltvExpiry&& o) { MinFinalCltvExpiry_free(self); self = o.self; memset(&o, 0, sizeof(MinFinalCltvExpiry)); return *this; }
-	LDKMinFinalCltvExpiry* operator &() { return &self; }
-	LDKMinFinalCltvExpiry* operator ->() { return &self; }
-	const LDKMinFinalCltvExpiry* operator &() const { return &self; }
-	const LDKMinFinalCltvExpiry* operator ->() const { return &self; }
+	MinFinalCltvExpiryDelta(const MinFinalCltvExpiryDelta&) = delete;
+	MinFinalCltvExpiryDelta(MinFinalCltvExpiryDelta&& o) : self(o.self) { memset(&o, 0, sizeof(MinFinalCltvExpiryDelta)); }
+	MinFinalCltvExpiryDelta(LDKMinFinalCltvExpiryDelta&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMinFinalCltvExpiryDelta)); }
+	operator LDKMinFinalCltvExpiryDelta() && { LDKMinFinalCltvExpiryDelta res = self; memset(&self, 0, sizeof(LDKMinFinalCltvExpiryDelta)); return res; }
+	~MinFinalCltvExpiryDelta() { MinFinalCltvExpiryDelta_free(self); }
+	MinFinalCltvExpiryDelta& operator=(MinFinalCltvExpiryDelta&& o) { MinFinalCltvExpiryDelta_free(self); self = o.self; memset(&o, 0, sizeof(MinFinalCltvExpiryDelta)); return *this; }
+	LDKMinFinalCltvExpiryDelta* operator &() { return &self; }
+	LDKMinFinalCltvExpiryDelta* operator ->() { return &self; }
+	const LDKMinFinalCltvExpiryDelta* operator &() const { return &self; }
+	const LDKMinFinalCltvExpiryDelta* operator ->() const { return &self; }
 };
 class Fallback {
 private:
@@ -2667,250 +3459,9 @@ public:
 	const LDKSignOrCreationError* operator &() const { return &self; }
 	const LDKSignOrCreationError* operator ->() const { return &self; }
 };
-class ChannelMonitorUpdate {
+class RapidGossipSync {
 private:
-	LDKChannelMonitorUpdate self;
-public:
-	ChannelMonitorUpdate(const ChannelMonitorUpdate&) = delete;
-	ChannelMonitorUpdate(ChannelMonitorUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitorUpdate)); }
-	ChannelMonitorUpdate(LDKChannelMonitorUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitorUpdate)); }
-	operator LDKChannelMonitorUpdate() && { LDKChannelMonitorUpdate res = self; memset(&self, 0, sizeof(LDKChannelMonitorUpdate)); return res; }
-	~ChannelMonitorUpdate() { ChannelMonitorUpdate_free(self); }
-	ChannelMonitorUpdate& operator=(ChannelMonitorUpdate&& o) { ChannelMonitorUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMonitorUpdate)); return *this; }
-	LDKChannelMonitorUpdate* operator &() { return &self; }
-	LDKChannelMonitorUpdate* operator ->() { return &self; }
-	const LDKChannelMonitorUpdate* operator &() const { return &self; }
-	const LDKChannelMonitorUpdate* operator ->() const { return &self; }
-};
-class MonitorEvent {
-private:
-	LDKMonitorEvent self;
-public:
-	MonitorEvent(const MonitorEvent&) = delete;
-	MonitorEvent(MonitorEvent&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorEvent)); }
-	MonitorEvent(LDKMonitorEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorEvent)); }
-	operator LDKMonitorEvent() && { LDKMonitorEvent res = self; memset(&self, 0, sizeof(LDKMonitorEvent)); return res; }
-	~MonitorEvent() { MonitorEvent_free(self); }
-	MonitorEvent& operator=(MonitorEvent&& o) { MonitorEvent_free(self); self = o.self; memset(&o, 0, sizeof(MonitorEvent)); return *this; }
-	LDKMonitorEvent* operator &() { return &self; }
-	LDKMonitorEvent* operator ->() { return &self; }
-	const LDKMonitorEvent* operator &() const { return &self; }
-	const LDKMonitorEvent* operator ->() const { return &self; }
-};
-class HTLCUpdate {
-private:
-	LDKHTLCUpdate self;
-public:
-	HTLCUpdate(const HTLCUpdate&) = delete;
-	HTLCUpdate(HTLCUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCUpdate)); }
-	HTLCUpdate(LDKHTLCUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCUpdate)); }
-	operator LDKHTLCUpdate() && { LDKHTLCUpdate res = self; memset(&self, 0, sizeof(LDKHTLCUpdate)); return res; }
-	~HTLCUpdate() { HTLCUpdate_free(self); }
-	HTLCUpdate& operator=(HTLCUpdate&& o) { HTLCUpdate_free(self); self = o.self; memset(&o, 0, sizeof(HTLCUpdate)); return *this; }
-	LDKHTLCUpdate* operator &() { return &self; }
-	LDKHTLCUpdate* operator ->() { return &self; }
-	const LDKHTLCUpdate* operator &() const { return &self; }
-	const LDKHTLCUpdate* operator ->() const { return &self; }
-};
-class Balance {
-private:
-	LDKBalance self;
-public:
-	Balance(const Balance&) = delete;
-	Balance(Balance&& o) : self(o.self) { memset(&o, 0, sizeof(Balance)); }
-	Balance(LDKBalance&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBalance)); }
-	operator LDKBalance() && { LDKBalance res = self; memset(&self, 0, sizeof(LDKBalance)); return res; }
-	~Balance() { Balance_free(self); }
-	Balance& operator=(Balance&& o) { Balance_free(self); self = o.self; memset(&o, 0, sizeof(Balance)); return *this; }
-	LDKBalance* operator &() { return &self; }
-	LDKBalance* operator ->() { return &self; }
-	const LDKBalance* operator &() const { return &self; }
-	const LDKBalance* operator ->() const { return &self; }
-};
-class ChannelMonitor {
-private:
-	LDKChannelMonitor self;
-public:
-	ChannelMonitor(const ChannelMonitor&) = delete;
-	ChannelMonitor(ChannelMonitor&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitor)); }
-	ChannelMonitor(LDKChannelMonitor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitor)); }
-	operator LDKChannelMonitor() && { LDKChannelMonitor res = self; memset(&self, 0, sizeof(LDKChannelMonitor)); return res; }
-	~ChannelMonitor() { ChannelMonitor_free(self); }
-	ChannelMonitor& operator=(ChannelMonitor&& o) { ChannelMonitor_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMonitor)); return *this; }
-	LDKChannelMonitor* operator &() { return &self; }
-	LDKChannelMonitor* operator ->() { return &self; }
-	const LDKChannelMonitor* operator &() const { return &self; }
-	const LDKChannelMonitor* operator ->() const { return &self; }
-};
-class ExpandedKey {
-private:
-	LDKExpandedKey self;
-public:
-	ExpandedKey(const ExpandedKey&) = delete;
-	ExpandedKey(ExpandedKey&& o) : self(o.self) { memset(&o, 0, sizeof(ExpandedKey)); }
-	ExpandedKey(LDKExpandedKey&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKExpandedKey)); }
-	operator LDKExpandedKey() && { LDKExpandedKey res = self; memset(&self, 0, sizeof(LDKExpandedKey)); return res; }
-	~ExpandedKey() { ExpandedKey_free(self); }
-	ExpandedKey& operator=(ExpandedKey&& o) { ExpandedKey_free(self); self = o.self; memset(&o, 0, sizeof(ExpandedKey)); return *this; }
-	LDKExpandedKey* operator &() { return &self; }
-	LDKExpandedKey* operator ->() { return &self; }
-	const LDKExpandedKey* operator &() const { return &self; }
-	const LDKExpandedKey* operator ->() const { return &self; }
-};
-class CustomMessageHandler {
-private:
-	LDKCustomMessageHandler self;
-public:
-	CustomMessageHandler(const CustomMessageHandler&) = delete;
-	CustomMessageHandler(CustomMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(CustomMessageHandler)); }
-	CustomMessageHandler(LDKCustomMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCustomMessageHandler)); }
-	operator LDKCustomMessageHandler() && { LDKCustomMessageHandler res = self; memset(&self, 0, sizeof(LDKCustomMessageHandler)); return res; }
-	~CustomMessageHandler() { CustomMessageHandler_free(self); }
-	CustomMessageHandler& operator=(CustomMessageHandler&& o) { CustomMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(CustomMessageHandler)); return *this; }
-	LDKCustomMessageHandler* operator &() { return &self; }
-	LDKCustomMessageHandler* operator ->() { return &self; }
-	const LDKCustomMessageHandler* operator &() const { return &self; }
-	const LDKCustomMessageHandler* operator ->() const { return &self; }
-	/**
-	 *  Called with the message type that was received and the buffer to be read.
-	 *  Can return a `MessageHandlingError` if the message could not be handled.
-	 */
-	inline LDK::CResult_NoneLightningErrorZ handle_custom_message(struct LDKType msg, struct LDKPublicKey sender_node_id);
-	/**
-	 *  Gets the list of pending messages which were generated by the custom message
-	 *  handler, clearing the list in the process. The first tuple element must
-	 *  correspond to the intended recipients node ids. If no connection to one of the
-	 *  specified node does not exist, the message is simply not sent to it.
-	 */
-	inline LDK::CVec_C2Tuple_PublicKeyTypeZZ get_and_clear_pending_msg();
-};
-class IgnoringMessageHandler {
-private:
-	LDKIgnoringMessageHandler self;
-public:
-	IgnoringMessageHandler(const IgnoringMessageHandler&) = delete;
-	IgnoringMessageHandler(IgnoringMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(IgnoringMessageHandler)); }
-	IgnoringMessageHandler(LDKIgnoringMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKIgnoringMessageHandler)); }
-	operator LDKIgnoringMessageHandler() && { LDKIgnoringMessageHandler res = self; memset(&self, 0, sizeof(LDKIgnoringMessageHandler)); return res; }
-	~IgnoringMessageHandler() { IgnoringMessageHandler_free(self); }
-	IgnoringMessageHandler& operator=(IgnoringMessageHandler&& o) { IgnoringMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(IgnoringMessageHandler)); return *this; }
-	LDKIgnoringMessageHandler* operator &() { return &self; }
-	LDKIgnoringMessageHandler* operator ->() { return &self; }
-	const LDKIgnoringMessageHandler* operator &() const { return &self; }
-	const LDKIgnoringMessageHandler* operator ->() const { return &self; }
-};
-class ErroringMessageHandler {
-private:
-	LDKErroringMessageHandler self;
-public:
-	ErroringMessageHandler(const ErroringMessageHandler&) = delete;
-	ErroringMessageHandler(ErroringMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(ErroringMessageHandler)); }
-	ErroringMessageHandler(LDKErroringMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErroringMessageHandler)); }
-	operator LDKErroringMessageHandler() && { LDKErroringMessageHandler res = self; memset(&self, 0, sizeof(LDKErroringMessageHandler)); return res; }
-	~ErroringMessageHandler() { ErroringMessageHandler_free(self); }
-	ErroringMessageHandler& operator=(ErroringMessageHandler&& o) { ErroringMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(ErroringMessageHandler)); return *this; }
-	LDKErroringMessageHandler* operator &() { return &self; }
-	LDKErroringMessageHandler* operator ->() { return &self; }
-	const LDKErroringMessageHandler* operator &() const { return &self; }
-	const LDKErroringMessageHandler* operator ->() const { return &self; }
-};
-class MessageHandler {
-private:
-	LDKMessageHandler self;
-public:
-	MessageHandler(const MessageHandler&) = delete;
-	MessageHandler(MessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(MessageHandler)); }
-	MessageHandler(LDKMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageHandler)); }
-	operator LDKMessageHandler() && { LDKMessageHandler res = self; memset(&self, 0, sizeof(LDKMessageHandler)); return res; }
-	~MessageHandler() { MessageHandler_free(self); }
-	MessageHandler& operator=(MessageHandler&& o) { MessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(MessageHandler)); return *this; }
-	LDKMessageHandler* operator &() { return &self; }
-	LDKMessageHandler* operator ->() { return &self; }
-	const LDKMessageHandler* operator &() const { return &self; }
-	const LDKMessageHandler* operator ->() const { return &self; }
-};
-class SocketDescriptor {
-private:
-	LDKSocketDescriptor self;
-public:
-	SocketDescriptor(const SocketDescriptor&) = delete;
-	SocketDescriptor(SocketDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(SocketDescriptor)); }
-	SocketDescriptor(LDKSocketDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSocketDescriptor)); }
-	operator LDKSocketDescriptor() && { LDKSocketDescriptor res = self; memset(&self, 0, sizeof(LDKSocketDescriptor)); return res; }
-	~SocketDescriptor() { SocketDescriptor_free(self); }
-	SocketDescriptor& operator=(SocketDescriptor&& o) { SocketDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(SocketDescriptor)); return *this; }
-	LDKSocketDescriptor* operator &() { return &self; }
-	LDKSocketDescriptor* operator ->() { return &self; }
-	const LDKSocketDescriptor* operator &() const { return &self; }
-	const LDKSocketDescriptor* operator ->() const { return &self; }
-	/**
-	 *  Attempts to send some data from the given slice to the peer.
-	 * 
-	 *  Returns the amount of data which was sent, possibly 0 if the socket has since disconnected.
-	 *  Note that in the disconnected case, [`PeerManager::socket_disconnected`] must still be
-	 *  called and further write attempts may occur until that time.
-	 * 
-	 *  If the returned size is smaller than `data.len()`, a
-	 *  [`PeerManager::write_buffer_space_avail`] call must be made the next time more data can be
-	 *  written. Additionally, until a `send_data` event completes fully, no further
-	 *  [`PeerManager::read_event`] calls should be made for the same peer! Because this is to
-	 *  prevent denial-of-service issues, you should not read or buffer any data from the socket
-	 *  until then.
-	 * 
-	 *  If a [`PeerManager::read_event`] call on this descriptor had previously returned true
-	 *  (indicating that read events should be paused to prevent DoS in the send buffer),
-	 *  `resume_read` may be set indicating that read events on this descriptor should resume. A
-	 *  `resume_read` of false carries no meaning, and should not cause any action.
-	 */
-	inline uintptr_t send_data(struct LDKu8slice data, bool resume_read);
-	/**
-	 *  Disconnect the socket pointed to by this SocketDescriptor.
-	 * 
-	 *  You do *not* need to call [`PeerManager::socket_disconnected`] with this socket after this
-	 *  call (doing so is a noop).
-	 */
-	inline void disconnect_socket();
-	/** Checks if two objects are equal given this object's this_arg pointer and another object. */
-	inline bool eq(const struct LDKSocketDescriptor *NONNULL_PTR other_arg);
-	/**
-	 * Calculate a succinct non-cryptographic hash for an object given its this_arg pointer.
-	 * This is used, for example, for inclusion of this object in a hash map.
-	 */
-	inline uint64_t hash();
-};
-class PeerHandleError {
-private:
-	LDKPeerHandleError self;
-public:
-	PeerHandleError(const PeerHandleError&) = delete;
-	PeerHandleError(PeerHandleError&& o) : self(o.self) { memset(&o, 0, sizeof(PeerHandleError)); }
-	PeerHandleError(LDKPeerHandleError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeerHandleError)); }
-	operator LDKPeerHandleError() && { LDKPeerHandleError res = self; memset(&self, 0, sizeof(LDKPeerHandleError)); return res; }
-	~PeerHandleError() { PeerHandleError_free(self); }
-	PeerHandleError& operator=(PeerHandleError&& o) { PeerHandleError_free(self); self = o.self; memset(&o, 0, sizeof(PeerHandleError)); return *this; }
-	LDKPeerHandleError* operator &() { return &self; }
-	LDKPeerHandleError* operator ->() { return &self; }
-	const LDKPeerHandleError* operator &() const { return &self; }
-	const LDKPeerHandleError* operator ->() const { return &self; }
-};
-class PeerManager {
-private:
-	LDKPeerManager self;
-public:
-	PeerManager(const PeerManager&) = delete;
-	PeerManager(PeerManager&& o) : self(o.self) { memset(&o, 0, sizeof(PeerManager)); }
-	PeerManager(LDKPeerManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeerManager)); }
-	operator LDKPeerManager() && { LDKPeerManager res = self; memset(&self, 0, sizeof(LDKPeerManager)); return res; }
-	~PeerManager() { PeerManager_free(self); }
-	PeerManager& operator=(PeerManager&& o) { PeerManager_free(self); self = o.self; memset(&o, 0, sizeof(PeerManager)); return *this; }
-	LDKPeerManager* operator &() { return &self; }
-	LDKPeerManager* operator ->() { return &self; }
-	const LDKPeerManager* operator &() const { return &self; }
-	const LDKPeerManager* operator ->() const { return &self; }
-};
-class RapidGossipSync {
-private:
-	LDKRapidGossipSync self;
+	LDKRapidGossipSync self;
 public:
 	RapidGossipSync(const RapidGossipSync&) = delete;
 	RapidGossipSync(RapidGossipSync&& o) : self(o.self) { memset(&o, 0, sizeof(RapidGossipSync)); }
@@ -2946,9 +3497,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 +3726,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;
@@ -3325,6 +3891,21 @@ public:
 	const LDKNetAddress* operator &() const { return &self; }
 	const LDKNetAddress* operator ->() const { return &self; }
 };
+class UnsignedGossipMessage {
+private:
+	LDKUnsignedGossipMessage self;
+public:
+	UnsignedGossipMessage(const UnsignedGossipMessage&) = delete;
+	UnsignedGossipMessage(UnsignedGossipMessage&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedGossipMessage)); }
+	UnsignedGossipMessage(LDKUnsignedGossipMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedGossipMessage)); }
+	operator LDKUnsignedGossipMessage() && { LDKUnsignedGossipMessage res = self; memset(&self, 0, sizeof(LDKUnsignedGossipMessage)); return res; }
+	~UnsignedGossipMessage() { UnsignedGossipMessage_free(self); }
+	UnsignedGossipMessage& operator=(UnsignedGossipMessage&& o) { UnsignedGossipMessage_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedGossipMessage)); return *this; }
+	LDKUnsignedGossipMessage* operator &() { return &self; }
+	LDKUnsignedGossipMessage* operator ->() { return &self; }
+	const LDKUnsignedGossipMessage* operator &() const { return &self; }
+	const LDKUnsignedGossipMessage* operator ->() const { return &self; }
+};
 class UnsignedNodeAnnouncement {
 private:
 	LDKUnsignedNodeAnnouncement self;
@@ -3550,88 +4131,103 @@ public:
 	const LDKChannelMessageHandler* operator &() const { return &self; }
 	const LDKChannelMessageHandler* operator ->() const { return &self; }
 	/**
-	 *  Handle an incoming open_channel message from the given peer.
+	 *  Handle an incoming `open_channel` message from the given peer.
 	 */
-	inline void handle_open_channel(struct LDKPublicKey their_node_id, struct LDKInitFeatures their_features, const struct LDKOpenChannel *NONNULL_PTR msg);
+	inline void handle_open_channel(struct LDKPublicKey their_node_id, const struct LDKOpenChannel *NONNULL_PTR msg);
 	/**
-	 *  Handle an incoming accept_channel message from the given peer.
+	 *  Handle an incoming `accept_channel` message from the given peer.
 	 */
-	inline void handle_accept_channel(struct LDKPublicKey their_node_id, struct LDKInitFeatures their_features, const struct LDKAcceptChannel *NONNULL_PTR msg);
+	inline void handle_accept_channel(struct LDKPublicKey their_node_id, const struct LDKAcceptChannel *NONNULL_PTR msg);
 	/**
-	 *  Handle an incoming funding_created message from the given peer.
+	 *  Handle an incoming `funding_created` message from the given peer.
 	 */
 	inline void handle_funding_created(struct LDKPublicKey their_node_id, const struct LDKFundingCreated *NONNULL_PTR msg);
 	/**
-	 *  Handle an incoming funding_signed message from the given peer.
+	 *  Handle an incoming `funding_signed` message from the given peer.
 	 */
 	inline void handle_funding_signed(struct LDKPublicKey their_node_id, const struct LDKFundingSigned *NONNULL_PTR msg);
 	/**
-	 *  Handle an incoming channel_ready message from the given peer.
+	 *  Handle an incoming `channel_ready` message from the given peer.
 	 */
 	inline void handle_channel_ready(struct LDKPublicKey their_node_id, const struct LDKChannelReady *NONNULL_PTR msg);
 	/**
-	 *  Handle an incoming shutdown message from the given peer.
+	 *  Handle an incoming `shutdown` message from the given peer.
 	 */
-	inline void handle_shutdown(struct LDKPublicKey their_node_id, const struct LDKInitFeatures *NONNULL_PTR their_features, const struct LDKShutdown *NONNULL_PTR msg);
+	inline void handle_shutdown(struct LDKPublicKey their_node_id, const struct LDKShutdown *NONNULL_PTR msg);
 	/**
-	 *  Handle an incoming closing_signed message from the given peer.
+	 *  Handle an incoming `closing_signed` message from the given peer.
 	 */
 	inline void handle_closing_signed(struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg);
 	/**
-	 *  Handle an incoming update_add_htlc message from the given peer.
+	 *  Handle an incoming `update_add_htlc` message from the given peer.
 	 */
 	inline void handle_update_add_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateAddHTLC *NONNULL_PTR msg);
 	/**
-	 *  Handle an incoming update_fulfill_htlc message from the given peer.
+	 *  Handle an incoming `update_fulfill_htlc` message from the given peer.
 	 */
 	inline void handle_update_fulfill_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFulfillHTLC *NONNULL_PTR msg);
 	/**
-	 *  Handle an incoming update_fail_htlc message from the given peer.
+	 *  Handle an incoming `update_fail_htlc` message from the given peer.
 	 */
 	inline void handle_update_fail_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFailHTLC *NONNULL_PTR msg);
 	/**
-	 *  Handle an incoming update_fail_malformed_htlc message from the given peer.
+	 *  Handle an incoming `update_fail_malformed_htlc` message from the given peer.
 	 */
 	inline void handle_update_fail_malformed_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR msg);
 	/**
-	 *  Handle an incoming commitment_signed message from the given peer.
+	 *  Handle an incoming `commitment_signed` message from the given peer.
 	 */
 	inline void handle_commitment_signed(struct LDKPublicKey their_node_id, const struct LDKCommitmentSigned *NONNULL_PTR msg);
 	/**
-	 *  Handle an incoming revoke_and_ack message from the given peer.
+	 *  Handle an incoming `revoke_and_ack` message from the given peer.
 	 */
 	inline void handle_revoke_and_ack(struct LDKPublicKey their_node_id, const struct LDKRevokeAndACK *NONNULL_PTR msg);
 	/**
-	 *  Handle an incoming update_fee message from the given peer.
+	 *  Handle an incoming `update_fee` message from the given peer.
 	 */
 	inline void handle_update_fee(struct LDKPublicKey their_node_id, const struct LDKUpdateFee *NONNULL_PTR msg);
 	/**
-	 *  Handle an incoming announcement_signatures message from the given peer.
+	 *  Handle an incoming `announcement_signatures` message from the given peer.
 	 */
 	inline void handle_announcement_signatures(struct LDKPublicKey their_node_id, const struct LDKAnnouncementSignatures *NONNULL_PTR msg);
 	/**
-	 *  Indicates a connection to the peer failed/an existing connection was lost. If no connection
-	 *  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.
+	 *  Indicates a connection to the peer failed/an existing connection was lost.
 	 */
-	inline void peer_disconnected(struct LDKPublicKey their_node_id, bool no_connection_possible);
+	inline void peer_disconnected(struct LDKPublicKey their_node_id);
 	/**
-	 *  Handle a peer reconnecting, possibly generating channel_reestablish message(s).
+	 *  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, bool inbound);
 	/**
-	 *  Handle an incoming channel_reestablish message from the given peer.
+	 *  Handle an incoming `channel_reestablish` message from the given peer.
 	 */
 	inline void handle_channel_reestablish(struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg);
 	/**
-	 *  Handle an incoming channel update from the given peer.
+	 *  Handle an incoming `channel_update` message from the given peer.
 	 */
 	inline void handle_channel_update(struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg);
 	/**
-	 *  Handle an incoming error message from the given peer.
+	 *  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:
@@ -3648,41 +4244,46 @@ public:
 	const LDKRoutingMessageHandler* operator &() const { return &self; }
 	const LDKRoutingMessageHandler* operator ->() const { return &self; }
 	/**
-	 *  Handle an incoming node_announcement message, returning true if it should be forwarded on,
-	 *  false or returning an Err otherwise.
+	 *  Handle an incoming `node_announcement` message, returning `true` if it should be forwarded on,
+	 *  `false` or returning an `Err` otherwise.
 	 */
 	inline LDK::CResult_boolLightningErrorZ handle_node_announcement(const struct LDKNodeAnnouncement *NONNULL_PTR msg);
 	/**
-	 *  Handle a channel_announcement message, returning true if it should be forwarded on, false
-	 *  or returning an Err otherwise.
+	 *  Handle a `channel_announcement` message, returning `true` if it should be forwarded on, `false`
+	 *  or returning an `Err` otherwise.
 	 */
 	inline LDK::CResult_boolLightningErrorZ handle_channel_announcement(const struct LDKChannelAnnouncement *NONNULL_PTR msg);
 	/**
-	 *  Handle an incoming channel_update message, returning true if it should be forwarded on,
-	 *  false or returning an Err otherwise.
+	 *  Handle an incoming `channel_update` message, returning true if it should be forwarded on,
+	 *  `false` or returning an `Err` otherwise.
 	 */
 	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.
-	 *  If None is provided for starting_point, we start at the first node.
+	 *  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 LDKNodeId 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, bool inbound);
 	/**
 	 *  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
@@ -3697,15 +4298,83 @@ public:
 	 */
 	inline LDK::CResult_NoneLightningErrorZ handle_reply_short_channel_ids_end(struct LDKPublicKey their_node_id, struct LDKReplyShortChannelIdsEnd msg);
 	/**
-	 *  Handles when a peer asks us to send a list of short_channel_ids
+	 *  Handles when a peer asks us to send a list of `short_channel_id`s
 	 *  for the requested range of blocks.
 	 */
 	inline LDK::CResult_NoneLightningErrorZ handle_query_channel_range(struct LDKPublicKey their_node_id, struct LDKQueryChannelRange msg);
 	/**
 	 *  Handles when a peer asks us to send routing gossip messages for a
-	 *  list of short_channel_ids.
+	 *  list of `short_channel_id`s.
 	 */
 	inline LDK::CResult_NoneLightningErrorZ handle_query_short_channel_ids(struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg);
+	/**
+	 *  Indicates that there are a large number of [`ChannelAnnouncement`] (or other) messages
+	 *  pending some async action. While there is no guarantee of the rate of future messages, the
+	 *  caller should seek to reduce the rate of new gossip messages handled, especially
+	 *  [`ChannelAnnouncement`]s.
+	 */
+	inline bool processing_queue_high();
+	/**
+	 *  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, bool inbound);
+	/**
+	 *  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.
+	 */
+	inline void peer_disconnected(struct LDKPublicKey their_node_id);
+	/**
+	 *  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:
@@ -3722,21 +4391,6 @@ public:
 	const LDKGraphSyncError* operator &() const { return &self; }
 	const LDKGraphSyncError* operator ->() const { return &self; }
 };
-class DefaultRouter {
-private:
-	LDKDefaultRouter self;
-public:
-	DefaultRouter(const DefaultRouter&) = delete;
-	DefaultRouter(DefaultRouter&& o) : self(o.self) { memset(&o, 0, sizeof(DefaultRouter)); }
-	DefaultRouter(LDKDefaultRouter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDefaultRouter)); }
-	operator LDKDefaultRouter() && { LDKDefaultRouter res = self; memset(&self, 0, sizeof(LDKDefaultRouter)); return res; }
-	~DefaultRouter() { DefaultRouter_free(self); }
-	DefaultRouter& operator=(DefaultRouter&& o) { DefaultRouter_free(self); self = o.self; memset(&o, 0, sizeof(DefaultRouter)); return *this; }
-	LDKDefaultRouter* operator &() { return &self; }
-	LDKDefaultRouter* operator ->() { return &self; }
-	const LDKDefaultRouter* operator &() const { return &self; }
-	const LDKDefaultRouter* operator ->() const { return &self; }
-};
 class Level {
 private:
 	LDKLevel self;
@@ -3785,6 +4439,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 +4511,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 +4547,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, struct LDKChannelMonitorUpdate update, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id);
 };
 class LockedChannelMonitor {
 private:
@@ -3886,20 +4574,1880 @@ public:
 	const LDKLockedChannelMonitor* operator &() const { return &self; }
 	const LDKLockedChannelMonitor* operator ->() const { return &self; }
 };
-class ChainMonitor {
+class ChainMonitor {
+private:
+	LDKChainMonitor self;
+public:
+	ChainMonitor(const ChainMonitor&) = delete;
+	ChainMonitor(ChainMonitor&& o) : self(o.self) { memset(&o, 0, sizeof(ChainMonitor)); }
+	ChainMonitor(LDKChainMonitor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChainMonitor)); }
+	operator LDKChainMonitor() && { LDKChainMonitor res = self; memset(&self, 0, sizeof(LDKChainMonitor)); return res; }
+	~ChainMonitor() { ChainMonitor_free(self); }
+	ChainMonitor& operator=(ChainMonitor&& o) { ChainMonitor_free(self); self = o.self; memset(&o, 0, sizeof(ChainMonitor)); return *this; }
+	LDKChainMonitor* operator &() { return &self; }
+	LDKChainMonitor* operator ->() { return &self; }
+	const LDKChainMonitor* operator &() const { return &self; }
+	const LDKChainMonitor* operator ->() const { return &self; }
+};
+class CResult_LockedChannelMonitorNoneZ {
+private:
+	LDKCResult_LockedChannelMonitorNoneZ self;
+public:
+	CResult_LockedChannelMonitorNoneZ(const CResult_LockedChannelMonitorNoneZ&) = delete;
+	CResult_LockedChannelMonitorNoneZ(CResult_LockedChannelMonitorNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_LockedChannelMonitorNoneZ)); }
+	CResult_LockedChannelMonitorNoneZ(LDKCResult_LockedChannelMonitorNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_LockedChannelMonitorNoneZ)); }
+	operator LDKCResult_LockedChannelMonitorNoneZ() && { LDKCResult_LockedChannelMonitorNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_LockedChannelMonitorNoneZ)); return res; }
+	~CResult_LockedChannelMonitorNoneZ() { CResult_LockedChannelMonitorNoneZ_free(self); }
+	CResult_LockedChannelMonitorNoneZ& operator=(CResult_LockedChannelMonitorNoneZ&& o) { CResult_LockedChannelMonitorNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_LockedChannelMonitorNoneZ)); return *this; }
+	LDKCResult_LockedChannelMonitorNoneZ* operator &() { return &self; }
+	LDKCResult_LockedChannelMonitorNoneZ* operator ->() { return &self; }
+	const LDKCResult_LockedChannelMonitorNoneZ* operator &() const { return &self; }
+	const LDKCResult_LockedChannelMonitorNoneZ* operator ->() const { return &self; }
+};
+class CResult_PhantomRouteHintsDecodeErrorZ {
+private:
+	LDKCResult_PhantomRouteHintsDecodeErrorZ self;
+public:
+	CResult_PhantomRouteHintsDecodeErrorZ(const CResult_PhantomRouteHintsDecodeErrorZ&) = delete;
+	CResult_PhantomRouteHintsDecodeErrorZ(CResult_PhantomRouteHintsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PhantomRouteHintsDecodeErrorZ)); }
+	CResult_PhantomRouteHintsDecodeErrorZ(LDKCResult_PhantomRouteHintsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ)); }
+	operator LDKCResult_PhantomRouteHintsDecodeErrorZ() && { LDKCResult_PhantomRouteHintsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ)); return res; }
+	~CResult_PhantomRouteHintsDecodeErrorZ() { CResult_PhantomRouteHintsDecodeErrorZ_free(self); }
+	CResult_PhantomRouteHintsDecodeErrorZ& operator=(CResult_PhantomRouteHintsDecodeErrorZ&& o) { CResult_PhantomRouteHintsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PhantomRouteHintsDecodeErrorZ)); return *this; }
+	LDKCResult_PhantomRouteHintsDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_PhantomRouteHintsDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_PhantomRouteHintsDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_PhantomRouteHintsDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ {
+private:
+	LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ self;
+public:
+	CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ(const CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ&) = delete;
+	CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ(CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ)); }
+	CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ)); }
+	operator LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ() && { LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ)); return res; }
+	~CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ() { CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_free(self); }
+	CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ& operator=(CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ&& o) { CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ)); return *this; }
+	LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* operator &() { return &self; }
+	LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* operator ->() { return &self; }
+	const LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* operator &() const { return &self; }
+	const LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* operator ->() const { return &self; }
+};
+class CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ {
+private:
+	LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ self;
+public:
+	CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ(const CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ&) = delete;
+	CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ(CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ)); }
+	CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ(LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ)); }
+	operator LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ() && { LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ)); return res; }
+	~CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ() { CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(self); }
+	CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ& operator=(CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ&& o) { CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ)); return *this; }
+	LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ* operator &() { return &self; }
+	LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ* operator ->() { return &self; }
+	const LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ* operator &() const { return &self; }
+	const LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ* operator ->() const { return &self; }
+};
+class CVec_C2Tuple_u32TxOutZZ {
+private:
+	LDKCVec_C2Tuple_u32TxOutZZ self;
+public:
+	CVec_C2Tuple_u32TxOutZZ(const CVec_C2Tuple_u32TxOutZZ&) = delete;
+	CVec_C2Tuple_u32TxOutZZ(CVec_C2Tuple_u32TxOutZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_u32TxOutZZ)); }
+	CVec_C2Tuple_u32TxOutZZ(LDKCVec_C2Tuple_u32TxOutZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_u32TxOutZZ)); }
+	operator LDKCVec_C2Tuple_u32TxOutZZ() && { LDKCVec_C2Tuple_u32TxOutZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_u32TxOutZZ)); return res; }
+	~CVec_C2Tuple_u32TxOutZZ() { CVec_C2Tuple_u32TxOutZZ_free(self); }
+	CVec_C2Tuple_u32TxOutZZ& operator=(CVec_C2Tuple_u32TxOutZZ&& o) { CVec_C2Tuple_u32TxOutZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_u32TxOutZZ)); return *this; }
+	LDKCVec_C2Tuple_u32TxOutZZ* operator &() { return &self; }
+	LDKCVec_C2Tuple_u32TxOutZZ* operator ->() { return &self; }
+	const LDKCVec_C2Tuple_u32TxOutZZ* operator &() const { return &self; }
+	const LDKCVec_C2Tuple_u32TxOutZZ* operator ->() const { return &self; }
+};
+class CResult_FundingCreatedDecodeErrorZ {
+private:
+	LDKCResult_FundingCreatedDecodeErrorZ self;
+public:
+	CResult_FundingCreatedDecodeErrorZ(const CResult_FundingCreatedDecodeErrorZ&) = delete;
+	CResult_FundingCreatedDecodeErrorZ(CResult_FundingCreatedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FundingCreatedDecodeErrorZ)); }
+	CResult_FundingCreatedDecodeErrorZ(LDKCResult_FundingCreatedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FundingCreatedDecodeErrorZ)); }
+	operator LDKCResult_FundingCreatedDecodeErrorZ() && { LDKCResult_FundingCreatedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FundingCreatedDecodeErrorZ)); return res; }
+	~CResult_FundingCreatedDecodeErrorZ() { CResult_FundingCreatedDecodeErrorZ_free(self); }
+	CResult_FundingCreatedDecodeErrorZ& operator=(CResult_FundingCreatedDecodeErrorZ&& o) { CResult_FundingCreatedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FundingCreatedDecodeErrorZ)); return *this; }
+	LDKCResult_FundingCreatedDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_FundingCreatedDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_FundingCreatedDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_FundingCreatedDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_ChannelInfoDecodeErrorZ {
+private:
+	LDKCResult_ChannelInfoDecodeErrorZ self;
+public:
+	CResult_ChannelInfoDecodeErrorZ(const CResult_ChannelInfoDecodeErrorZ&) = delete;
+	CResult_ChannelInfoDecodeErrorZ(CResult_ChannelInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelInfoDecodeErrorZ)); }
+	CResult_ChannelInfoDecodeErrorZ(LDKCResult_ChannelInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelInfoDecodeErrorZ)); }
+	operator LDKCResult_ChannelInfoDecodeErrorZ() && { LDKCResult_ChannelInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelInfoDecodeErrorZ)); return res; }
+	~CResult_ChannelInfoDecodeErrorZ() { CResult_ChannelInfoDecodeErrorZ_free(self); }
+	CResult_ChannelInfoDecodeErrorZ& operator=(CResult_ChannelInfoDecodeErrorZ&& o) { CResult_ChannelInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelInfoDecodeErrorZ)); return *this; }
+	LDKCResult_ChannelInfoDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_ChannelInfoDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_ChannelInfoDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_ChannelInfoDecodeErrorZ* 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_CVec_u8ZPeerHandleErrorZ {
+private:
+	LDKCResult_CVec_u8ZPeerHandleErrorZ self;
+public:
+	CResult_CVec_u8ZPeerHandleErrorZ(const CResult_CVec_u8ZPeerHandleErrorZ&) = delete;
+	CResult_CVec_u8ZPeerHandleErrorZ(CResult_CVec_u8ZPeerHandleErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_u8ZPeerHandleErrorZ)); }
+	CResult_CVec_u8ZPeerHandleErrorZ(LDKCResult_CVec_u8ZPeerHandleErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ)); }
+	operator LDKCResult_CVec_u8ZPeerHandleErrorZ() && { LDKCResult_CVec_u8ZPeerHandleErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ)); return res; }
+	~CResult_CVec_u8ZPeerHandleErrorZ() { CResult_CVec_u8ZPeerHandleErrorZ_free(self); }
+	CResult_CVec_u8ZPeerHandleErrorZ& operator=(CResult_CVec_u8ZPeerHandleErrorZ&& o) { CResult_CVec_u8ZPeerHandleErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_u8ZPeerHandleErrorZ)); return *this; }
+	LDKCResult_CVec_u8ZPeerHandleErrorZ* operator &() { return &self; }
+	LDKCResult_CVec_u8ZPeerHandleErrorZ* operator ->() { return &self; }
+	const LDKCResult_CVec_u8ZPeerHandleErrorZ* operator &() const { return &self; }
+	const LDKCResult_CVec_u8ZPeerHandleErrorZ* operator ->() const { return &self; }
+};
+class CResult_GossipTimestampFilterDecodeErrorZ {
+private:
+	LDKCResult_GossipTimestampFilterDecodeErrorZ 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 COption_NetworkUpdateZ {
+private:
+	LDKCOption_NetworkUpdateZ self;
+public:
+	COption_NetworkUpdateZ(const COption_NetworkUpdateZ&) = delete;
+	COption_NetworkUpdateZ(COption_NetworkUpdateZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_NetworkUpdateZ)); }
+	COption_NetworkUpdateZ(LDKCOption_NetworkUpdateZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_NetworkUpdateZ)); }
+	operator LDKCOption_NetworkUpdateZ() && { LDKCOption_NetworkUpdateZ res = self; memset(&self, 0, sizeof(LDKCOption_NetworkUpdateZ)); return res; }
+	~COption_NetworkUpdateZ() { COption_NetworkUpdateZ_free(self); }
+	COption_NetworkUpdateZ& operator=(COption_NetworkUpdateZ&& o) { COption_NetworkUpdateZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_NetworkUpdateZ)); return *this; }
+	LDKCOption_NetworkUpdateZ* operator &() { return &self; }
+	LDKCOption_NetworkUpdateZ* operator ->() { return &self; }
+	const LDKCOption_NetworkUpdateZ* operator &() const { return &self; }
+	const LDKCOption_NetworkUpdateZ* operator ->() const { return &self; }
+};
+class COption_u64Z {
+private:
+	LDKCOption_u64Z self;
+public:
+	COption_u64Z(const COption_u64Z&) = delete;
+	COption_u64Z(COption_u64Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_u64Z)); }
+	COption_u64Z(LDKCOption_u64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_u64Z)); }
+	operator LDKCOption_u64Z() && { LDKCOption_u64Z res = self; memset(&self, 0, sizeof(LDKCOption_u64Z)); return res; }
+	~COption_u64Z() { COption_u64Z_free(self); }
+	COption_u64Z& operator=(COption_u64Z&& o) { COption_u64Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_u64Z)); return *this; }
+	LDKCOption_u64Z* operator &() { return &self; }
+	LDKCOption_u64Z* operator ->() { return &self; }
+	const LDKCOption_u64Z* operator &() const { return &self; }
+	const LDKCOption_u64Z* operator ->() const { return &self; }
+};
+class CResult_PaymentPreimageAPIErrorZ {
+private:
+	LDKCResult_PaymentPreimageAPIErrorZ self;
+public:
+	CResult_PaymentPreimageAPIErrorZ(const CResult_PaymentPreimageAPIErrorZ&) = delete;
+	CResult_PaymentPreimageAPIErrorZ(CResult_PaymentPreimageAPIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentPreimageAPIErrorZ)); }
+	CResult_PaymentPreimageAPIErrorZ(LDKCResult_PaymentPreimageAPIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentPreimageAPIErrorZ)); }
+	operator LDKCResult_PaymentPreimageAPIErrorZ() && { LDKCResult_PaymentPreimageAPIErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentPreimageAPIErrorZ)); return res; }
+	~CResult_PaymentPreimageAPIErrorZ() { CResult_PaymentPreimageAPIErrorZ_free(self); }
+	CResult_PaymentPreimageAPIErrorZ& operator=(CResult_PaymentPreimageAPIErrorZ&& o) { CResult_PaymentPreimageAPIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentPreimageAPIErrorZ)); return *this; }
+	LDKCResult_PaymentPreimageAPIErrorZ* operator &() { return &self; }
+	LDKCResult_PaymentPreimageAPIErrorZ* operator ->() { return &self; }
+	const LDKCResult_PaymentPreimageAPIErrorZ* operator &() const { return &self; }
+	const LDKCResult_PaymentPreimageAPIErrorZ* operator ->() const { return &self; }
+};
+class CResult_RouteHintDecodeErrorZ {
+private:
+	LDKCResult_RouteHintDecodeErrorZ self;
+public:
+	CResult_RouteHintDecodeErrorZ(const CResult_RouteHintDecodeErrorZ&) = delete;
+	CResult_RouteHintDecodeErrorZ(CResult_RouteHintDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteHintDecodeErrorZ)); }
+	CResult_RouteHintDecodeErrorZ(LDKCResult_RouteHintDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteHintDecodeErrorZ)); }
+	operator LDKCResult_RouteHintDecodeErrorZ() && { LDKCResult_RouteHintDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteHintDecodeErrorZ)); return res; }
+	~CResult_RouteHintDecodeErrorZ() { CResult_RouteHintDecodeErrorZ_free(self); }
+	CResult_RouteHintDecodeErrorZ& operator=(CResult_RouteHintDecodeErrorZ&& o) { CResult_RouteHintDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteHintDecodeErrorZ)); return *this; }
+	LDKCResult_RouteHintDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_RouteHintDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_RouteHintDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_RouteHintDecodeErrorZ* operator ->() const { return &self; }
+};
+class COption_FilterZ {
+private:
+	LDKCOption_FilterZ 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; }
+};
+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_COption_APIErrorZDecodeErrorZ {
+private:
+	LDKCResult_COption_APIErrorZDecodeErrorZ self;
+public:
+	CResult_COption_APIErrorZDecodeErrorZ(const CResult_COption_APIErrorZDecodeErrorZ&) = delete;
+	CResult_COption_APIErrorZDecodeErrorZ(CResult_COption_APIErrorZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_APIErrorZDecodeErrorZ)); }
+	CResult_COption_APIErrorZDecodeErrorZ(LDKCResult_COption_APIErrorZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_APIErrorZDecodeErrorZ)); }
+	operator LDKCResult_COption_APIErrorZDecodeErrorZ() && { LDKCResult_COption_APIErrorZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_APIErrorZDecodeErrorZ)); return res; }
+	~CResult_COption_APIErrorZDecodeErrorZ() { CResult_COption_APIErrorZDecodeErrorZ_free(self); }
+	CResult_COption_APIErrorZDecodeErrorZ& operator=(CResult_COption_APIErrorZDecodeErrorZ&& o) { CResult_COption_APIErrorZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_APIErrorZDecodeErrorZ)); return *this; }
+	LDKCResult_COption_APIErrorZDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_COption_APIErrorZDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_COption_APIErrorZDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_COption_APIErrorZDecodeErrorZ* operator ->() const { return &self; }
+};
+class CVec_UpdateAddHTLCZ {
+private:
+	LDKCVec_UpdateAddHTLCZ self;
+public:
+	CVec_UpdateAddHTLCZ(const CVec_UpdateAddHTLCZ&) = delete;
+	CVec_UpdateAddHTLCZ(CVec_UpdateAddHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateAddHTLCZ)); }
+	CVec_UpdateAddHTLCZ(LDKCVec_UpdateAddHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateAddHTLCZ)); }
+	operator LDKCVec_UpdateAddHTLCZ() && { LDKCVec_UpdateAddHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateAddHTLCZ)); return res; }
+	~CVec_UpdateAddHTLCZ() { CVec_UpdateAddHTLCZ_free(self); }
+	CVec_UpdateAddHTLCZ& operator=(CVec_UpdateAddHTLCZ&& o) { CVec_UpdateAddHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateAddHTLCZ)); return *this; }
+	LDKCVec_UpdateAddHTLCZ* operator &() { return &self; }
+	LDKCVec_UpdateAddHTLCZ* operator ->() { return &self; }
+	const LDKCVec_UpdateAddHTLCZ* operator &() const { return &self; }
+	const LDKCVec_UpdateAddHTLCZ* 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 COption_u32Z {
+private:
+	LDKCOption_u32Z self;
+public:
+	COption_u32Z(const COption_u32Z&) = delete;
+	COption_u32Z(COption_u32Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_u32Z)); }
+	COption_u32Z(LDKCOption_u32Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_u32Z)); }
+	operator LDKCOption_u32Z() && { LDKCOption_u32Z res = self; memset(&self, 0, sizeof(LDKCOption_u32Z)); return res; }
+	~COption_u32Z() { COption_u32Z_free(self); }
+	COption_u32Z& operator=(COption_u32Z&& o) { COption_u32Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_u32Z)); return *this; }
+	LDKCOption_u32Z* operator &() { return &self; }
+	LDKCOption_u32Z* operator ->() { return &self; }
+	const LDKCOption_u32Z* operator &() const { return &self; }
+	const LDKCOption_u32Z* operator ->() const { return &self; }
+};
+class CResult_StaticPaymentOutputDescriptorDecodeErrorZ {
+private:
+	LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ self;
+public:
+	CResult_StaticPaymentOutputDescriptorDecodeErrorZ(const CResult_StaticPaymentOutputDescriptorDecodeErrorZ&) = delete;
+	CResult_StaticPaymentOutputDescriptorDecodeErrorZ(CResult_StaticPaymentOutputDescriptorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_StaticPaymentOutputDescriptorDecodeErrorZ)); }
+	CResult_StaticPaymentOutputDescriptorDecodeErrorZ(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ)); }
+	operator LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ() && { LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ)); return res; }
+	~CResult_StaticPaymentOutputDescriptorDecodeErrorZ() { CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(self); }
+	CResult_StaticPaymentOutputDescriptorDecodeErrorZ& operator=(CResult_StaticPaymentOutputDescriptorDecodeErrorZ&& o) { CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_StaticPaymentOutputDescriptorDecodeErrorZ)); return *this; }
+	LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator ->() const { return &self; }
+};
+class CVec_C2Tuple_TxidBlockHashZZ {
+private:
+	LDKCVec_C2Tuple_TxidBlockHashZZ self;
+public:
+	CVec_C2Tuple_TxidBlockHashZZ(const CVec_C2Tuple_TxidBlockHashZZ&) = delete;
+	CVec_C2Tuple_TxidBlockHashZZ(CVec_C2Tuple_TxidBlockHashZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_TxidBlockHashZZ)); }
+	CVec_C2Tuple_TxidBlockHashZZ(LDKCVec_C2Tuple_TxidBlockHashZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_TxidBlockHashZZ)); }
+	operator LDKCVec_C2Tuple_TxidBlockHashZZ() && { LDKCVec_C2Tuple_TxidBlockHashZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_TxidBlockHashZZ)); return res; }
+	~CVec_C2Tuple_TxidBlockHashZZ() { CVec_C2Tuple_TxidBlockHashZZ_free(self); }
+	CVec_C2Tuple_TxidBlockHashZZ& operator=(CVec_C2Tuple_TxidBlockHashZZ&& o) { CVec_C2Tuple_TxidBlockHashZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_TxidBlockHashZZ)); return *this; }
+	LDKCVec_C2Tuple_TxidBlockHashZZ* operator &() { return &self; }
+	LDKCVec_C2Tuple_TxidBlockHashZZ* operator ->() { return &self; }
+	const LDKCVec_C2Tuple_TxidBlockHashZZ* operator &() const { return &self; }
+	const LDKCVec_C2Tuple_TxidBlockHashZZ* operator ->() const { return &self; }
+};
+class CResult_CommitmentTransactionDecodeErrorZ {
+private:
+	LDKCResult_CommitmentTransactionDecodeErrorZ self;
+public:
+	CResult_CommitmentTransactionDecodeErrorZ(const CResult_CommitmentTransactionDecodeErrorZ&) = delete;
+	CResult_CommitmentTransactionDecodeErrorZ(CResult_CommitmentTransactionDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CommitmentTransactionDecodeErrorZ)); }
+	CResult_CommitmentTransactionDecodeErrorZ(LDKCResult_CommitmentTransactionDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ)); }
+	operator LDKCResult_CommitmentTransactionDecodeErrorZ() && { LDKCResult_CommitmentTransactionDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ)); return res; }
+	~CResult_CommitmentTransactionDecodeErrorZ() { CResult_CommitmentTransactionDecodeErrorZ_free(self); }
+	CResult_CommitmentTransactionDecodeErrorZ& operator=(CResult_CommitmentTransactionDecodeErrorZ&& o) { CResult_CommitmentTransactionDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CommitmentTransactionDecodeErrorZ)); return *this; }
+	LDKCResult_CommitmentTransactionDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_CommitmentTransactionDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_CommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_CommitmentTransactionDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_TransactionNoneZ {
+private:
+	LDKCResult_TransactionNoneZ self;
+public:
+	CResult_TransactionNoneZ(const CResult_TransactionNoneZ&) = delete;
+	CResult_TransactionNoneZ(CResult_TransactionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TransactionNoneZ)); }
+	CResult_TransactionNoneZ(LDKCResult_TransactionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TransactionNoneZ)); }
+	operator LDKCResult_TransactionNoneZ() && { LDKCResult_TransactionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TransactionNoneZ)); return res; }
+	~CResult_TransactionNoneZ() { CResult_TransactionNoneZ_free(self); }
+	CResult_TransactionNoneZ& operator=(CResult_TransactionNoneZ&& o) { CResult_TransactionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TransactionNoneZ)); return *this; }
+	LDKCResult_TransactionNoneZ* operator &() { return &self; }
+	LDKCResult_TransactionNoneZ* operator ->() { return &self; }
+	const LDKCResult_TransactionNoneZ* operator &() const { return &self; }
+	const LDKCResult_TransactionNoneZ* operator ->() const { return &self; }
+};
+class CResult_ClosingSignedFeeRangeDecodeErrorZ {
+private:
+	LDKCResult_ClosingSignedFeeRangeDecodeErrorZ self;
+public:
+	CResult_ClosingSignedFeeRangeDecodeErrorZ(const CResult_ClosingSignedFeeRangeDecodeErrorZ&) = delete;
+	CResult_ClosingSignedFeeRangeDecodeErrorZ(CResult_ClosingSignedFeeRangeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ClosingSignedFeeRangeDecodeErrorZ)); }
+	CResult_ClosingSignedFeeRangeDecodeErrorZ(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ)); }
+	operator LDKCResult_ClosingSignedFeeRangeDecodeErrorZ() && { LDKCResult_ClosingSignedFeeRangeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ)); return res; }
+	~CResult_ClosingSignedFeeRangeDecodeErrorZ() { CResult_ClosingSignedFeeRangeDecodeErrorZ_free(self); }
+	CResult_ClosingSignedFeeRangeDecodeErrorZ& operator=(CResult_ClosingSignedFeeRangeDecodeErrorZ&& o) { CResult_ClosingSignedFeeRangeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ClosingSignedFeeRangeDecodeErrorZ)); return *this; }
+	LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_ErrorMessageDecodeErrorZ {
+private:
+	LDKCResult_ErrorMessageDecodeErrorZ self;
+public:
+	CResult_ErrorMessageDecodeErrorZ(const CResult_ErrorMessageDecodeErrorZ&) = delete;
+	CResult_ErrorMessageDecodeErrorZ(CResult_ErrorMessageDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ErrorMessageDecodeErrorZ)); }
+	CResult_ErrorMessageDecodeErrorZ(LDKCResult_ErrorMessageDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ErrorMessageDecodeErrorZ)); }
+	operator LDKCResult_ErrorMessageDecodeErrorZ() && { LDKCResult_ErrorMessageDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ErrorMessageDecodeErrorZ)); return res; }
+	~CResult_ErrorMessageDecodeErrorZ() { CResult_ErrorMessageDecodeErrorZ_free(self); }
+	CResult_ErrorMessageDecodeErrorZ& operator=(CResult_ErrorMessageDecodeErrorZ&& o) { CResult_ErrorMessageDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ErrorMessageDecodeErrorZ)); return *this; }
+	LDKCResult_ErrorMessageDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_ErrorMessageDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_ErrorMessageDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_ErrorMessageDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_OpenChannelDecodeErrorZ {
+private:
+	LDKCResult_OpenChannelDecodeErrorZ self;
+public:
+	CResult_OpenChannelDecodeErrorZ(const CResult_OpenChannelDecodeErrorZ&) = delete;
+	CResult_OpenChannelDecodeErrorZ(CResult_OpenChannelDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OpenChannelDecodeErrorZ)); }
+	CResult_OpenChannelDecodeErrorZ(LDKCResult_OpenChannelDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OpenChannelDecodeErrorZ)); }
+	operator LDKCResult_OpenChannelDecodeErrorZ() && { LDKCResult_OpenChannelDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OpenChannelDecodeErrorZ)); return res; }
+	~CResult_OpenChannelDecodeErrorZ() { CResult_OpenChannelDecodeErrorZ_free(self); }
+	CResult_OpenChannelDecodeErrorZ& operator=(CResult_OpenChannelDecodeErrorZ&& o) { CResult_OpenChannelDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OpenChannelDecodeErrorZ)); return *this; }
+	LDKCResult_OpenChannelDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_OpenChannelDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_OpenChannelDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_OpenChannelDecodeErrorZ* operator ->() const { return &self; }
+};
+class COption_APIErrorZ {
+private:
+	LDKCOption_APIErrorZ self;
+public:
+	COption_APIErrorZ(const COption_APIErrorZ&) = delete;
+	COption_APIErrorZ(COption_APIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_APIErrorZ)); }
+	COption_APIErrorZ(LDKCOption_APIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_APIErrorZ)); }
+	operator LDKCOption_APIErrorZ() && { LDKCOption_APIErrorZ res = self; memset(&self, 0, sizeof(LDKCOption_APIErrorZ)); return res; }
+	~COption_APIErrorZ() { COption_APIErrorZ_free(self); }
+	COption_APIErrorZ& operator=(COption_APIErrorZ&& o) { COption_APIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_APIErrorZ)); return *this; }
+	LDKCOption_APIErrorZ* operator &() { return &self; }
+	LDKCOption_APIErrorZ* operator ->() { return &self; }
+	const LDKCOption_APIErrorZ* operator &() const { return &self; }
+	const LDKCOption_APIErrorZ* operator ->() const { return &self; }
+};
+class CResult_QueryChannelRangeDecodeErrorZ {
+private:
+	LDKCResult_QueryChannelRangeDecodeErrorZ self;
+public:
+	CResult_QueryChannelRangeDecodeErrorZ(const CResult_QueryChannelRangeDecodeErrorZ&) = delete;
+	CResult_QueryChannelRangeDecodeErrorZ(CResult_QueryChannelRangeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_QueryChannelRangeDecodeErrorZ)); }
+	CResult_QueryChannelRangeDecodeErrorZ(LDKCResult_QueryChannelRangeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ)); }
+	operator LDKCResult_QueryChannelRangeDecodeErrorZ() && { LDKCResult_QueryChannelRangeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ)); return res; }
+	~CResult_QueryChannelRangeDecodeErrorZ() { CResult_QueryChannelRangeDecodeErrorZ_free(self); }
+	CResult_QueryChannelRangeDecodeErrorZ& operator=(CResult_QueryChannelRangeDecodeErrorZ&& o) { CResult_QueryChannelRangeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_QueryChannelRangeDecodeErrorZ)); return *this; }
+	LDKCResult_QueryChannelRangeDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_QueryChannelRangeDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_QueryChannelRangeDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_QueryChannelRangeDecodeErrorZ* operator ->() const { return &self; }
+};
+class CVec_TransactionZ {
+private:
+	LDKCVec_TransactionZ self;
+public:
+	CVec_TransactionZ(const CVec_TransactionZ&) = delete;
+	CVec_TransactionZ(CVec_TransactionZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TransactionZ)); }
+	CVec_TransactionZ(LDKCVec_TransactionZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TransactionZ)); }
+	operator LDKCVec_TransactionZ() && { LDKCVec_TransactionZ res = self; memset(&self, 0, sizeof(LDKCVec_TransactionZ)); return res; }
+	~CVec_TransactionZ() { CVec_TransactionZ_free(self); }
+	CVec_TransactionZ& operator=(CVec_TransactionZ&& o) { CVec_TransactionZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TransactionZ)); return *this; }
+	LDKCVec_TransactionZ* operator &() { return &self; }
+	LDKCVec_TransactionZ* operator ->() { return &self; }
+	const LDKCVec_TransactionZ* operator &() const { return &self; }
+	const LDKCVec_TransactionZ* operator ->() const { return &self; }
+};
+class C2Tuple_TxidBlockHashZ {
+private:
+	LDKC2Tuple_TxidBlockHashZ self;
+public:
+	C2Tuple_TxidBlockHashZ(const C2Tuple_TxidBlockHashZ&) = delete;
+	C2Tuple_TxidBlockHashZ(C2Tuple_TxidBlockHashZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_TxidBlockHashZ)); }
+	C2Tuple_TxidBlockHashZ(LDKC2Tuple_TxidBlockHashZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_TxidBlockHashZ)); }
+	operator LDKC2Tuple_TxidBlockHashZ() && { LDKC2Tuple_TxidBlockHashZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_TxidBlockHashZ)); return res; }
+	~C2Tuple_TxidBlockHashZ() { C2Tuple_TxidBlockHashZ_free(self); }
+	C2Tuple_TxidBlockHashZ& operator=(C2Tuple_TxidBlockHashZ&& o) { C2Tuple_TxidBlockHashZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_TxidBlockHashZ)); return *this; }
+	LDKC2Tuple_TxidBlockHashZ* operator &() { return &self; }
+	LDKC2Tuple_TxidBlockHashZ* operator ->() { return &self; }
+	const LDKC2Tuple_TxidBlockHashZ* operator &() const { return &self; }
+	const LDKC2Tuple_TxidBlockHashZ* operator ->() const { return &self; }
+};
+class CResult_ChannelFeaturesDecodeErrorZ {
+private:
+	LDKCResult_ChannelFeaturesDecodeErrorZ self;
+public:
+	CResult_ChannelFeaturesDecodeErrorZ(const CResult_ChannelFeaturesDecodeErrorZ&) = delete;
+	CResult_ChannelFeaturesDecodeErrorZ(CResult_ChannelFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelFeaturesDecodeErrorZ)); }
+	CResult_ChannelFeaturesDecodeErrorZ(LDKCResult_ChannelFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ)); }
+	operator LDKCResult_ChannelFeaturesDecodeErrorZ() && { LDKCResult_ChannelFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ)); return res; }
+	~CResult_ChannelFeaturesDecodeErrorZ() { CResult_ChannelFeaturesDecodeErrorZ_free(self); }
+	CResult_ChannelFeaturesDecodeErrorZ& operator=(CResult_ChannelFeaturesDecodeErrorZ&& o) { CResult_ChannelFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelFeaturesDecodeErrorZ)); return *this; }
+	LDKCResult_ChannelFeaturesDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_ChannelFeaturesDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_ChannelFeaturesDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_ChannelFeaturesDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_ChannelReadyDecodeErrorZ {
+private:
+	LDKCResult_ChannelReadyDecodeErrorZ self;
+public:
+	CResult_ChannelReadyDecodeErrorZ(const CResult_ChannelReadyDecodeErrorZ&) = delete;
+	CResult_ChannelReadyDecodeErrorZ(CResult_ChannelReadyDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelReadyDecodeErrorZ)); }
+	CResult_ChannelReadyDecodeErrorZ(LDKCResult_ChannelReadyDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelReadyDecodeErrorZ)); }
+	operator LDKCResult_ChannelReadyDecodeErrorZ() && { LDKCResult_ChannelReadyDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelReadyDecodeErrorZ)); return res; }
+	~CResult_ChannelReadyDecodeErrorZ() { CResult_ChannelReadyDecodeErrorZ_free(self); }
+	CResult_ChannelReadyDecodeErrorZ& operator=(CResult_ChannelReadyDecodeErrorZ&& o) { CResult_ChannelReadyDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelReadyDecodeErrorZ)); return *this; }
+	LDKCResult_ChannelReadyDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_ChannelReadyDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_ChannelReadyDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_ChannelReadyDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_UpdateFeeDecodeErrorZ {
+private:
+	LDKCResult_UpdateFeeDecodeErrorZ self;
+public:
+	CResult_UpdateFeeDecodeErrorZ(const CResult_UpdateFeeDecodeErrorZ&) = delete;
+	CResult_UpdateFeeDecodeErrorZ(CResult_UpdateFeeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateFeeDecodeErrorZ)); }
+	CResult_UpdateFeeDecodeErrorZ(LDKCResult_UpdateFeeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateFeeDecodeErrorZ)); }
+	operator LDKCResult_UpdateFeeDecodeErrorZ() && { LDKCResult_UpdateFeeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateFeeDecodeErrorZ)); return res; }
+	~CResult_UpdateFeeDecodeErrorZ() { CResult_UpdateFeeDecodeErrorZ_free(self); }
+	CResult_UpdateFeeDecodeErrorZ& operator=(CResult_UpdateFeeDecodeErrorZ&& o) { CResult_UpdateFeeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateFeeDecodeErrorZ)); return *this; }
+	LDKCResult_UpdateFeeDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_UpdateFeeDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_UpdateFeeDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_UpdateFeeDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_HTLCOutputInCommitmentDecodeErrorZ {
+private:
+	LDKCResult_HTLCOutputInCommitmentDecodeErrorZ self;
+public:
+	CResult_HTLCOutputInCommitmentDecodeErrorZ(const CResult_HTLCOutputInCommitmentDecodeErrorZ&) = delete;
+	CResult_HTLCOutputInCommitmentDecodeErrorZ(CResult_HTLCOutputInCommitmentDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HTLCOutputInCommitmentDecodeErrorZ)); }
+	CResult_HTLCOutputInCommitmentDecodeErrorZ(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ)); }
+	operator LDKCResult_HTLCOutputInCommitmentDecodeErrorZ() && { LDKCResult_HTLCOutputInCommitmentDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ)); return res; }
+	~CResult_HTLCOutputInCommitmentDecodeErrorZ() { CResult_HTLCOutputInCommitmentDecodeErrorZ_free(self); }
+	CResult_HTLCOutputInCommitmentDecodeErrorZ& operator=(CResult_HTLCOutputInCommitmentDecodeErrorZ&& o) { CResult_HTLCOutputInCommitmentDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HTLCOutputInCommitmentDecodeErrorZ)); return *this; }
+	LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_boolLightningErrorZ {
+private:
+	LDKCResult_boolLightningErrorZ self;
+public:
+	CResult_boolLightningErrorZ(const CResult_boolLightningErrorZ&) = delete;
+	CResult_boolLightningErrorZ(CResult_boolLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_boolLightningErrorZ)); }
+	CResult_boolLightningErrorZ(LDKCResult_boolLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_boolLightningErrorZ)); }
+	operator LDKCResult_boolLightningErrorZ() && { LDKCResult_boolLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_boolLightningErrorZ)); return res; }
+	~CResult_boolLightningErrorZ() { CResult_boolLightningErrorZ_free(self); }
+	CResult_boolLightningErrorZ& operator=(CResult_boolLightningErrorZ&& o) { CResult_boolLightningErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_boolLightningErrorZ)); return *this; }
+	LDKCResult_boolLightningErrorZ* operator &() { return &self; }
+	LDKCResult_boolLightningErrorZ* operator ->() { return &self; }
+	const LDKCResult_boolLightningErrorZ* operator &() const { return &self; }
+	const LDKCResult_boolLightningErrorZ* operator ->() const { return &self; }
+};
+class CResult_NodeIdDecodeErrorZ {
+private:
+	LDKCResult_NodeIdDecodeErrorZ self;
+public:
+	CResult_NodeIdDecodeErrorZ(const CResult_NodeIdDecodeErrorZ&) = delete;
+	CResult_NodeIdDecodeErrorZ(CResult_NodeIdDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeIdDecodeErrorZ)); }
+	CResult_NodeIdDecodeErrorZ(LDKCResult_NodeIdDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeIdDecodeErrorZ)); }
+	operator LDKCResult_NodeIdDecodeErrorZ() && { LDKCResult_NodeIdDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeIdDecodeErrorZ)); return res; }
+	~CResult_NodeIdDecodeErrorZ() { CResult_NodeIdDecodeErrorZ_free(self); }
+	CResult_NodeIdDecodeErrorZ& operator=(CResult_NodeIdDecodeErrorZ&& o) { CResult_NodeIdDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeIdDecodeErrorZ)); return *this; }
+	LDKCResult_NodeIdDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_NodeIdDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_NodeIdDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_NodeIdDecodeErrorZ* 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 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;
+public:
+	CResult_ShutdownScriptInvalidShutdownScriptZ(const CResult_ShutdownScriptInvalidShutdownScriptZ&) = delete;
+	CResult_ShutdownScriptInvalidShutdownScriptZ(CResult_ShutdownScriptInvalidShutdownScriptZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ShutdownScriptInvalidShutdownScriptZ)); }
+	CResult_ShutdownScriptInvalidShutdownScriptZ(LDKCResult_ShutdownScriptInvalidShutdownScriptZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ)); }
+	operator LDKCResult_ShutdownScriptInvalidShutdownScriptZ() && { LDKCResult_ShutdownScriptInvalidShutdownScriptZ res = self; memset(&self, 0, sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ)); return res; }
+	~CResult_ShutdownScriptInvalidShutdownScriptZ() { CResult_ShutdownScriptInvalidShutdownScriptZ_free(self); }
+	CResult_ShutdownScriptInvalidShutdownScriptZ& operator=(CResult_ShutdownScriptInvalidShutdownScriptZ&& o) { CResult_ShutdownScriptInvalidShutdownScriptZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ShutdownScriptInvalidShutdownScriptZ)); return *this; }
+	LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator &() { return &self; }
+	LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator ->() { return &self; }
+	const LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator &() const { return &self; }
+	const LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator ->() const { return &self; }
+};
+class CResult_NodeAnnouncementInfoDecodeErrorZ {
+private:
+	LDKCResult_NodeAnnouncementInfoDecodeErrorZ self;
+public:
+	CResult_NodeAnnouncementInfoDecodeErrorZ(const CResult_NodeAnnouncementInfoDecodeErrorZ&) = delete;
+	CResult_NodeAnnouncementInfoDecodeErrorZ(CResult_NodeAnnouncementInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeAnnouncementInfoDecodeErrorZ)); }
+	CResult_NodeAnnouncementInfoDecodeErrorZ(LDKCResult_NodeAnnouncementInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ)); }
+	operator LDKCResult_NodeAnnouncementInfoDecodeErrorZ() && { LDKCResult_NodeAnnouncementInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ)); return res; }
+	~CResult_NodeAnnouncementInfoDecodeErrorZ() { CResult_NodeAnnouncementInfoDecodeErrorZ_free(self); }
+	CResult_NodeAnnouncementInfoDecodeErrorZ& operator=(CResult_NodeAnnouncementInfoDecodeErrorZ&& o) { CResult_NodeAnnouncementInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeAnnouncementInfoDecodeErrorZ)); return *this; }
+	LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_COption_NetworkUpdateZDecodeErrorZ {
+private:
+	LDKCResult_COption_NetworkUpdateZDecodeErrorZ self;
+public:
+	CResult_COption_NetworkUpdateZDecodeErrorZ(const CResult_COption_NetworkUpdateZDecodeErrorZ&) = delete;
+	CResult_COption_NetworkUpdateZDecodeErrorZ(CResult_COption_NetworkUpdateZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_NetworkUpdateZDecodeErrorZ)); }
+	CResult_COption_NetworkUpdateZDecodeErrorZ(LDKCResult_COption_NetworkUpdateZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ)); }
+	operator LDKCResult_COption_NetworkUpdateZDecodeErrorZ() && { LDKCResult_COption_NetworkUpdateZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ)); return res; }
+	~CResult_COption_NetworkUpdateZDecodeErrorZ() { CResult_COption_NetworkUpdateZDecodeErrorZ_free(self); }
+	CResult_COption_NetworkUpdateZDecodeErrorZ& operator=(CResult_COption_NetworkUpdateZDecodeErrorZ&& o) { CResult_COption_NetworkUpdateZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_NetworkUpdateZDecodeErrorZ)); return *this; }
+	LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_NoneRetryableSendFailureZ {
+private:
+	LDKCResult_NoneRetryableSendFailureZ self;
+public:
+	CResult_NoneRetryableSendFailureZ(const CResult_NoneRetryableSendFailureZ&) = delete;
+	CResult_NoneRetryableSendFailureZ(CResult_NoneRetryableSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneRetryableSendFailureZ)); }
+	CResult_NoneRetryableSendFailureZ(LDKCResult_NoneRetryableSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneRetryableSendFailureZ)); }
+	operator LDKCResult_NoneRetryableSendFailureZ() && { LDKCResult_NoneRetryableSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneRetryableSendFailureZ)); return res; }
+	~CResult_NoneRetryableSendFailureZ() { CResult_NoneRetryableSendFailureZ_free(self); }
+	CResult_NoneRetryableSendFailureZ& operator=(CResult_NoneRetryableSendFailureZ&& o) { CResult_NoneRetryableSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneRetryableSendFailureZ)); return *this; }
+	LDKCResult_NoneRetryableSendFailureZ* operator &() { return &self; }
+	LDKCResult_NoneRetryableSendFailureZ* operator ->() { return &self; }
+	const LDKCResult_NoneRetryableSendFailureZ* operator &() const { return &self; }
+	const LDKCResult_NoneRetryableSendFailureZ* operator ->() const { return &self; }
+};
+class CVec_UpdateFailMalformedHTLCZ {
+private:
+	LDKCVec_UpdateFailMalformedHTLCZ self;
+public:
+	CVec_UpdateFailMalformedHTLCZ(const CVec_UpdateFailMalformedHTLCZ&) = delete;
+	CVec_UpdateFailMalformedHTLCZ(CVec_UpdateFailMalformedHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateFailMalformedHTLCZ)); }
+	CVec_UpdateFailMalformedHTLCZ(LDKCVec_UpdateFailMalformedHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateFailMalformedHTLCZ)); }
+	operator LDKCVec_UpdateFailMalformedHTLCZ() && { LDKCVec_UpdateFailMalformedHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateFailMalformedHTLCZ)); return res; }
+	~CVec_UpdateFailMalformedHTLCZ() { CVec_UpdateFailMalformedHTLCZ_free(self); }
+	CVec_UpdateFailMalformedHTLCZ& operator=(CVec_UpdateFailMalformedHTLCZ&& o) { CVec_UpdateFailMalformedHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateFailMalformedHTLCZ)); return *this; }
+	LDKCVec_UpdateFailMalformedHTLCZ* operator &() { return &self; }
+	LDKCVec_UpdateFailMalformedHTLCZ* operator ->() { return &self; }
+	const LDKCVec_UpdateFailMalformedHTLCZ* operator &() const { return &self; }
+	const LDKCVec_UpdateFailMalformedHTLCZ* operator ->() const { return &self; }
+};
+class CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ {
+private:
+	LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ self;
+public:
+	CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ(const CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ&) = delete;
+	CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ(CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ)); }
+	CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ(LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ)); }
+	operator LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ() && { LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ)); return res; }
+	~CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ() { CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(self); }
+	CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ& operator=(CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ&& o) { CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ)); return *this; }
+	LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ* operator &() { return &self; }
+	LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ* operator ->() { return &self; }
+	const LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ* operator &() const { return &self; }
+	const LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ* operator ->() const { return &self; }
+};
+class CVec_C2Tuple_PublicKeyCOption_NetAddressZZZ {
+private:
+	LDKCVec_C2Tuple_PublicKeyCOption_NetAddressZZZ self;
+public:
+	CVec_C2Tuple_PublicKeyCOption_NetAddressZZZ(const CVec_C2Tuple_PublicKeyCOption_NetAddressZZZ&) = delete;
+	CVec_C2Tuple_PublicKeyCOption_NetAddressZZZ(CVec_C2Tuple_PublicKeyCOption_NetAddressZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_PublicKeyCOption_NetAddressZZZ)); }
+	CVec_C2Tuple_PublicKeyCOption_NetAddressZZZ(LDKCVec_C2Tuple_PublicKeyCOption_NetAddressZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_PublicKeyCOption_NetAddressZZZ)); }
+	operator LDKCVec_C2Tuple_PublicKeyCOption_NetAddressZZZ() && { LDKCVec_C2Tuple_PublicKeyCOption_NetAddressZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_PublicKeyCOption_NetAddressZZZ)); return res; }
+	~CVec_C2Tuple_PublicKeyCOption_NetAddressZZZ() { CVec_C2Tuple_PublicKeyCOption_NetAddressZZZ_free(self); }
+	CVec_C2Tuple_PublicKeyCOption_NetAddressZZZ& operator=(CVec_C2Tuple_PublicKeyCOption_NetAddressZZZ&& o) { CVec_C2Tuple_PublicKeyCOption_NetAddressZZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_PublicKeyCOption_NetAddressZZZ)); return *this; }
+	LDKCVec_C2Tuple_PublicKeyCOption_NetAddressZZZ* operator &() { return &self; }
+	LDKCVec_C2Tuple_PublicKeyCOption_NetAddressZZZ* operator ->() { return &self; }
+	const LDKCVec_C2Tuple_PublicKeyCOption_NetAddressZZZ* operator &() const { return &self; }
+	const LDKCVec_C2Tuple_PublicKeyCOption_NetAddressZZZ* operator ->() const { return &self; }
+};
+class CVec_RouteHopZ {
+private:
+	LDKCVec_RouteHopZ self;
+public:
+	CVec_RouteHopZ(const CVec_RouteHopZ&) = delete;
+	CVec_RouteHopZ(CVec_RouteHopZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RouteHopZ)); }
+	CVec_RouteHopZ(LDKCVec_RouteHopZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RouteHopZ)); }
+	operator LDKCVec_RouteHopZ() && { LDKCVec_RouteHopZ res = self; memset(&self, 0, sizeof(LDKCVec_RouteHopZ)); return res; }
+	~CVec_RouteHopZ() { CVec_RouteHopZ_free(self); }
+	CVec_RouteHopZ& operator=(CVec_RouteHopZ&& o) { CVec_RouteHopZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_RouteHopZ)); return *this; }
+	LDKCVec_RouteHopZ* operator &() { return &self; }
+	LDKCVec_RouteHopZ* operator ->() { return &self; }
+	const LDKCVec_RouteHopZ* operator &() const { return &self; }
+	const LDKCVec_RouteHopZ* 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 CVec_C2Tuple_BlockHashChannelMonitorZZ {
+private:
+	LDKCVec_C2Tuple_BlockHashChannelMonitorZZ self;
+public:
+	CVec_C2Tuple_BlockHashChannelMonitorZZ(const CVec_C2Tuple_BlockHashChannelMonitorZZ&) = delete;
+	CVec_C2Tuple_BlockHashChannelMonitorZZ(CVec_C2Tuple_BlockHashChannelMonitorZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_BlockHashChannelMonitorZZ)); }
+	CVec_C2Tuple_BlockHashChannelMonitorZZ(LDKCVec_C2Tuple_BlockHashChannelMonitorZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_BlockHashChannelMonitorZZ)); }
+	operator LDKCVec_C2Tuple_BlockHashChannelMonitorZZ() && { LDKCVec_C2Tuple_BlockHashChannelMonitorZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_BlockHashChannelMonitorZZ)); return res; }
+	~CVec_C2Tuple_BlockHashChannelMonitorZZ() { CVec_C2Tuple_BlockHashChannelMonitorZZ_free(self); }
+	CVec_C2Tuple_BlockHashChannelMonitorZZ& operator=(CVec_C2Tuple_BlockHashChannelMonitorZZ&& o) { CVec_C2Tuple_BlockHashChannelMonitorZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_BlockHashChannelMonitorZZ)); return *this; }
+	LDKCVec_C2Tuple_BlockHashChannelMonitorZZ* operator &() { return &self; }
+	LDKCVec_C2Tuple_BlockHashChannelMonitorZZ* operator ->() { return &self; }
+	const LDKCVec_C2Tuple_BlockHashChannelMonitorZZ* operator &() const { return &self; }
+	const LDKCVec_C2Tuple_BlockHashChannelMonitorZZ* operator ->() const { return &self; }
+};
+class CVec_ThirtyTwoBytesZ {
+private:
+	LDKCVec_ThirtyTwoBytesZ self;
+public:
+	CVec_ThirtyTwoBytesZ(const CVec_ThirtyTwoBytesZ&) = delete;
+	CVec_ThirtyTwoBytesZ(CVec_ThirtyTwoBytesZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ThirtyTwoBytesZ)); }
+	CVec_ThirtyTwoBytesZ(LDKCVec_ThirtyTwoBytesZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ThirtyTwoBytesZ)); }
+	operator LDKCVec_ThirtyTwoBytesZ() && { LDKCVec_ThirtyTwoBytesZ res = self; memset(&self, 0, sizeof(LDKCVec_ThirtyTwoBytesZ)); return res; }
+	~CVec_ThirtyTwoBytesZ() { CVec_ThirtyTwoBytesZ_free(self); }
+	CVec_ThirtyTwoBytesZ& operator=(CVec_ThirtyTwoBytesZ&& o) { CVec_ThirtyTwoBytesZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ThirtyTwoBytesZ)); return *this; }
+	LDKCVec_ThirtyTwoBytesZ* operator &() { return &self; }
+	LDKCVec_ThirtyTwoBytesZ* operator ->() { return &self; }
+	const LDKCVec_ThirtyTwoBytesZ* operator &() const { return &self; }
+	const LDKCVec_ThirtyTwoBytesZ* operator ->() const { return &self; }
+};
+class CResult_ClosingSignedDecodeErrorZ {
+private:
+	LDKCResult_ClosingSignedDecodeErrorZ self;
+public:
+	CResult_ClosingSignedDecodeErrorZ(const CResult_ClosingSignedDecodeErrorZ&) = delete;
+	CResult_ClosingSignedDecodeErrorZ(CResult_ClosingSignedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ClosingSignedDecodeErrorZ)); }
+	CResult_ClosingSignedDecodeErrorZ(LDKCResult_ClosingSignedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ClosingSignedDecodeErrorZ)); }
+	operator LDKCResult_ClosingSignedDecodeErrorZ() && { LDKCResult_ClosingSignedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ClosingSignedDecodeErrorZ)); return res; }
+	~CResult_ClosingSignedDecodeErrorZ() { CResult_ClosingSignedDecodeErrorZ_free(self); }
+	CResult_ClosingSignedDecodeErrorZ& operator=(CResult_ClosingSignedDecodeErrorZ&& o) { CResult_ClosingSignedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ClosingSignedDecodeErrorZ)); return *this; }
+	LDKCResult_ClosingSignedDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_ClosingSignedDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_ClosingSignedDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_ClosingSignedDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_NonePaymentErrorZ {
+private:
+	LDKCResult_NonePaymentErrorZ self;
+public:
+	CResult_NonePaymentErrorZ(const CResult_NonePaymentErrorZ&) = delete;
+	CResult_NonePaymentErrorZ(CResult_NonePaymentErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NonePaymentErrorZ)); }
+	CResult_NonePaymentErrorZ(LDKCResult_NonePaymentErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NonePaymentErrorZ)); }
+	operator LDKCResult_NonePaymentErrorZ() && { LDKCResult_NonePaymentErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NonePaymentErrorZ)); return res; }
+	~CResult_NonePaymentErrorZ() { CResult_NonePaymentErrorZ_free(self); }
+	CResult_NonePaymentErrorZ& operator=(CResult_NonePaymentErrorZ&& o) { CResult_NonePaymentErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NonePaymentErrorZ)); return *this; }
+	LDKCResult_NonePaymentErrorZ* operator &() { return &self; }
+	LDKCResult_NonePaymentErrorZ* operator ->() { return &self; }
+	const LDKCResult_NonePaymentErrorZ* operator &() const { return &self; }
+	const LDKCResult_NonePaymentErrorZ* operator ->() const { return &self; }
+};
+class CVec_CResult_NoneAPIErrorZZ {
+private:
+	LDKCVec_CResult_NoneAPIErrorZZ self;
+public:
+	CVec_CResult_NoneAPIErrorZZ(const CVec_CResult_NoneAPIErrorZZ&) = delete;
+	CVec_CResult_NoneAPIErrorZZ(CVec_CResult_NoneAPIErrorZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_CResult_NoneAPIErrorZZ)); }
+	CVec_CResult_NoneAPIErrorZZ(LDKCVec_CResult_NoneAPIErrorZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_CResult_NoneAPIErrorZZ)); }
+	operator LDKCVec_CResult_NoneAPIErrorZZ() && { LDKCVec_CResult_NoneAPIErrorZZ res = self; memset(&self, 0, sizeof(LDKCVec_CResult_NoneAPIErrorZZ)); return res; }
+	~CVec_CResult_NoneAPIErrorZZ() { CVec_CResult_NoneAPIErrorZZ_free(self); }
+	CVec_CResult_NoneAPIErrorZZ& operator=(CVec_CResult_NoneAPIErrorZZ&& o) { CVec_CResult_NoneAPIErrorZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_CResult_NoneAPIErrorZZ)); return *this; }
+	LDKCVec_CResult_NoneAPIErrorZZ* operator &() { return &self; }
+	LDKCVec_CResult_NoneAPIErrorZZ* operator ->() { return &self; }
+	const LDKCVec_CResult_NoneAPIErrorZZ* operator &() const { return &self; }
+	const LDKCVec_CResult_NoneAPIErrorZZ* operator ->() const { return &self; }
+};
+class CResult_CounterpartyCommitmentSecretsDecodeErrorZ {
+private:
+	LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ self;
+public:
+	CResult_CounterpartyCommitmentSecretsDecodeErrorZ(const CResult_CounterpartyCommitmentSecretsDecodeErrorZ&) = delete;
+	CResult_CounterpartyCommitmentSecretsDecodeErrorZ(CResult_CounterpartyCommitmentSecretsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CounterpartyCommitmentSecretsDecodeErrorZ)); }
+	CResult_CounterpartyCommitmentSecretsDecodeErrorZ(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ)); }
+	operator LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ() && { LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ)); return res; }
+	~CResult_CounterpartyCommitmentSecretsDecodeErrorZ() { CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(self); }
+	CResult_CounterpartyCommitmentSecretsDecodeErrorZ& operator=(CResult_CounterpartyCommitmentSecretsDecodeErrorZ&& o) { CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CounterpartyCommitmentSecretsDecodeErrorZ)); return *this; }
+	LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator ->() const { return &self; }
+};
+class CVec_RecentPaymentDetailsZ {
+private:
+	LDKCVec_RecentPaymentDetailsZ self;
+public:
+	CVec_RecentPaymentDetailsZ(const CVec_RecentPaymentDetailsZ&) = delete;
+	CVec_RecentPaymentDetailsZ(CVec_RecentPaymentDetailsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RecentPaymentDetailsZ)); }
+	CVec_RecentPaymentDetailsZ(LDKCVec_RecentPaymentDetailsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RecentPaymentDetailsZ)); }
+	operator LDKCVec_RecentPaymentDetailsZ() && { LDKCVec_RecentPaymentDetailsZ res = self; memset(&self, 0, sizeof(LDKCVec_RecentPaymentDetailsZ)); return res; }
+	~CVec_RecentPaymentDetailsZ() { CVec_RecentPaymentDetailsZ_free(self); }
+	CVec_RecentPaymentDetailsZ& operator=(CVec_RecentPaymentDetailsZ&& o) { CVec_RecentPaymentDetailsZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_RecentPaymentDetailsZ)); return *this; }
+	LDKCVec_RecentPaymentDetailsZ* operator &() { return &self; }
+	LDKCVec_RecentPaymentDetailsZ* operator ->() { return &self; }
+	const LDKCVec_RecentPaymentDetailsZ* operator &() const { return &self; }
+	const LDKCVec_RecentPaymentDetailsZ* operator ->() const { return &self; }
+};
+class CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ {
+private:
+	LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ self;
+public:
+	CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ(const CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ&) = delete;
+	CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ(CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ)); }
+	CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ)); }
+	operator LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ() && { LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ)); return res; }
+	~CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ() { CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(self); }
+	CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ& operator=(CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ&& o) { CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ)); return *this; }
+	LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* operator &() { return &self; }
+	LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* operator ->() { return &self; }
+	const LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* operator &() const { return &self; }
+	const LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* operator ->() const { return &self; }
+};
+class CVec_RouteHintHopZ {
+private:
+	LDKCVec_RouteHintHopZ self;
+public:
+	CVec_RouteHintHopZ(const CVec_RouteHintHopZ&) = delete;
+	CVec_RouteHintHopZ(CVec_RouteHintHopZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RouteHintHopZ)); }
+	CVec_RouteHintHopZ(LDKCVec_RouteHintHopZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RouteHintHopZ)); }
+	operator LDKCVec_RouteHintHopZ() && { LDKCVec_RouteHintHopZ res = self; memset(&self, 0, sizeof(LDKCVec_RouteHintHopZ)); return res; }
+	~CVec_RouteHintHopZ() { CVec_RouteHintHopZ_free(self); }
+	CVec_RouteHintHopZ& operator=(CVec_RouteHintHopZ&& o) { CVec_RouteHintHopZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_RouteHintHopZ)); return *this; }
+	LDKCVec_RouteHintHopZ* operator &() { return &self; }
+	LDKCVec_RouteHintHopZ* operator ->() { return &self; }
+	const LDKCVec_RouteHintHopZ* operator &() const { return &self; }
+	const LDKCVec_RouteHintHopZ* operator ->() const { return &self; }
+};
+class CResult_PaymentParametersDecodeErrorZ {
+private:
+	LDKCResult_PaymentParametersDecodeErrorZ self;
+public:
+	CResult_PaymentParametersDecodeErrorZ(const CResult_PaymentParametersDecodeErrorZ&) = delete;
+	CResult_PaymentParametersDecodeErrorZ(CResult_PaymentParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentParametersDecodeErrorZ)); }
+	CResult_PaymentParametersDecodeErrorZ(LDKCResult_PaymentParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentParametersDecodeErrorZ)); }
+	operator LDKCResult_PaymentParametersDecodeErrorZ() && { LDKCResult_PaymentParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentParametersDecodeErrorZ)); return res; }
+	~CResult_PaymentParametersDecodeErrorZ() { CResult_PaymentParametersDecodeErrorZ_free(self); }
+	CResult_PaymentParametersDecodeErrorZ& operator=(CResult_PaymentParametersDecodeErrorZ&& o) { CResult_PaymentParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentParametersDecodeErrorZ)); return *this; }
+	LDKCResult_PaymentParametersDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_PaymentParametersDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_PaymentParametersDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_PaymentParametersDecodeErrorZ* operator ->() const { return &self; }
+};
+class CVec_U5Z {
+private:
+	LDKCVec_U5Z self;
+public:
+	CVec_U5Z(const CVec_U5Z&) = delete;
+	CVec_U5Z(CVec_U5Z&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_U5Z)); }
+	CVec_U5Z(LDKCVec_U5Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_U5Z)); }
+	operator LDKCVec_U5Z() && { LDKCVec_U5Z res = self; memset(&self, 0, sizeof(LDKCVec_U5Z)); return res; }
+	~CVec_U5Z() { CVec_U5Z_free(self); }
+	CVec_U5Z& operator=(CVec_U5Z&& o) { CVec_U5Z_free(self); self = o.self; memset(&o, 0, sizeof(CVec_U5Z)); return *this; }
+	LDKCVec_U5Z* operator &() { return &self; }
+	LDKCVec_U5Z* operator ->() { return &self; }
+	const LDKCVec_U5Z* operator &() const { return &self; }
+	const LDKCVec_U5Z* operator ->() const { return &self; }
+};
+class COption_UtxoLookupZ {
+private:
+	LDKCOption_UtxoLookupZ self;
+public:
+	COption_UtxoLookupZ(const COption_UtxoLookupZ&) = delete;
+	COption_UtxoLookupZ(COption_UtxoLookupZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_UtxoLookupZ)); }
+	COption_UtxoLookupZ(LDKCOption_UtxoLookupZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_UtxoLookupZ)); }
+	operator LDKCOption_UtxoLookupZ() && { LDKCOption_UtxoLookupZ res = self; memset(&self, 0, sizeof(LDKCOption_UtxoLookupZ)); return res; }
+	~COption_UtxoLookupZ() { COption_UtxoLookupZ_free(self); }
+	COption_UtxoLookupZ& operator=(COption_UtxoLookupZ&& o) { COption_UtxoLookupZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_UtxoLookupZ)); return *this; }
+	LDKCOption_UtxoLookupZ* operator &() { return &self; }
+	LDKCOption_UtxoLookupZ* operator ->() { return &self; }
+	const LDKCOption_UtxoLookupZ* operator &() const { return &self; }
+	const LDKCOption_UtxoLookupZ* 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_UnsignedChannelAnnouncementDecodeErrorZ {
+private:
+	LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ 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; }
+};
+class C2Tuple_OutPointCVec_MonitorUpdateIdZZ {
+private:
+	LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ self;
+public:
+	C2Tuple_OutPointCVec_MonitorUpdateIdZZ(const C2Tuple_OutPointCVec_MonitorUpdateIdZZ&) = delete;
+	C2Tuple_OutPointCVec_MonitorUpdateIdZZ(C2Tuple_OutPointCVec_MonitorUpdateIdZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_OutPointCVec_MonitorUpdateIdZZ)); }
+	C2Tuple_OutPointCVec_MonitorUpdateIdZZ(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ)); }
+	operator LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ() && { LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ)); return res; }
+	~C2Tuple_OutPointCVec_MonitorUpdateIdZZ() { C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free(self); }
+	C2Tuple_OutPointCVec_MonitorUpdateIdZZ& operator=(C2Tuple_OutPointCVec_MonitorUpdateIdZZ&& o) { C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_OutPointCVec_MonitorUpdateIdZZ)); return *this; }
+	LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* operator &() { return &self; }
+	LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* operator ->() { return &self; }
+	const LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* operator &() const { return &self; }
+	const LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* operator ->() const { return &self; }
+};
+class CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ {
+private:
+	LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ self;
+public:
+	CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ(const CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ&) = delete;
+	CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ(CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ)); }
+	CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ)); }
+	operator LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ() && { LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ)); return res; }
+	~CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ() { CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(self); }
+	CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ& operator=(CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ&& o) { CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ)); return *this; }
+	LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* operator ->() const { return &self; }
+};
+class C2Tuple_BlockHashChannelManagerZ {
+private:
+	LDKC2Tuple_BlockHashChannelManagerZ self;
+public:
+	C2Tuple_BlockHashChannelManagerZ(const C2Tuple_BlockHashChannelManagerZ&) = delete;
+	C2Tuple_BlockHashChannelManagerZ(C2Tuple_BlockHashChannelManagerZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_BlockHashChannelManagerZ)); }
+	C2Tuple_BlockHashChannelManagerZ(LDKC2Tuple_BlockHashChannelManagerZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_BlockHashChannelManagerZ)); }
+	operator LDKC2Tuple_BlockHashChannelManagerZ() && { LDKC2Tuple_BlockHashChannelManagerZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_BlockHashChannelManagerZ)); return res; }
+	~C2Tuple_BlockHashChannelManagerZ() { C2Tuple_BlockHashChannelManagerZ_free(self); }
+	C2Tuple_BlockHashChannelManagerZ& operator=(C2Tuple_BlockHashChannelManagerZ&& o) { C2Tuple_BlockHashChannelManagerZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_BlockHashChannelManagerZ)); return *this; }
+	LDKC2Tuple_BlockHashChannelManagerZ* operator &() { return &self; }
+	LDKC2Tuple_BlockHashChannelManagerZ* operator ->() { return &self; }
+	const LDKC2Tuple_BlockHashChannelManagerZ* operator &() const { return &self; }
+	const LDKC2Tuple_BlockHashChannelManagerZ* operator ->() const { return &self; }
+};
+class CResult_ChannelTransactionParametersDecodeErrorZ {
+private:
+	LDKCResult_ChannelTransactionParametersDecodeErrorZ self;
+public:
+	CResult_ChannelTransactionParametersDecodeErrorZ(const CResult_ChannelTransactionParametersDecodeErrorZ&) = delete;
+	CResult_ChannelTransactionParametersDecodeErrorZ(CResult_ChannelTransactionParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelTransactionParametersDecodeErrorZ)); }
+	CResult_ChannelTransactionParametersDecodeErrorZ(LDKCResult_ChannelTransactionParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ)); }
+	operator LDKCResult_ChannelTransactionParametersDecodeErrorZ() && { LDKCResult_ChannelTransactionParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ)); return res; }
+	~CResult_ChannelTransactionParametersDecodeErrorZ() { CResult_ChannelTransactionParametersDecodeErrorZ_free(self); }
+	CResult_ChannelTransactionParametersDecodeErrorZ& operator=(CResult_ChannelTransactionParametersDecodeErrorZ&& o) { CResult_ChannelTransactionParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelTransactionParametersDecodeErrorZ)); return *this; }
+	LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_WriteableEcdsaChannelSignerDecodeErrorZ {
+private:
+	LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ self;
+public:
+	CResult_WriteableEcdsaChannelSignerDecodeErrorZ(const CResult_WriteableEcdsaChannelSignerDecodeErrorZ&) = delete;
+	CResult_WriteableEcdsaChannelSignerDecodeErrorZ(CResult_WriteableEcdsaChannelSignerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_WriteableEcdsaChannelSignerDecodeErrorZ)); }
+	CResult_WriteableEcdsaChannelSignerDecodeErrorZ(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ)); }
+	operator LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ() && { LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ)); return res; }
+	~CResult_WriteableEcdsaChannelSignerDecodeErrorZ() { CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free(self); }
+	CResult_WriteableEcdsaChannelSignerDecodeErrorZ& operator=(CResult_WriteableEcdsaChannelSignerDecodeErrorZ&& o) { CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_WriteableEcdsaChannelSignerDecodeErrorZ)); return *this; }
+	LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_DelayedPaymentOutputDescriptorDecodeErrorZ {
+private:
+	LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ self;
+public:
+	CResult_DelayedPaymentOutputDescriptorDecodeErrorZ(const CResult_DelayedPaymentOutputDescriptorDecodeErrorZ&) = delete;
+	CResult_DelayedPaymentOutputDescriptorDecodeErrorZ(CResult_DelayedPaymentOutputDescriptorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_DelayedPaymentOutputDescriptorDecodeErrorZ)); }
+	CResult_DelayedPaymentOutputDescriptorDecodeErrorZ(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ)); }
+	operator LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ() && { LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ)); return res; }
+	~CResult_DelayedPaymentOutputDescriptorDecodeErrorZ() { CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(self); }
+	CResult_DelayedPaymentOutputDescriptorDecodeErrorZ& operator=(CResult_DelayedPaymentOutputDescriptorDecodeErrorZ&& o) { CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_DelayedPaymentOutputDescriptorDecodeErrorZ)); return *this; }
+	LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator ->() const { return &self; }
+};
+class C2Tuple_PaymentHashPaymentIdZ {
+private:
+	LDKC2Tuple_PaymentHashPaymentIdZ self;
+public:
+	C2Tuple_PaymentHashPaymentIdZ(const C2Tuple_PaymentHashPaymentIdZ&) = delete;
+	C2Tuple_PaymentHashPaymentIdZ(C2Tuple_PaymentHashPaymentIdZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_PaymentHashPaymentIdZ)); }
+	C2Tuple_PaymentHashPaymentIdZ(LDKC2Tuple_PaymentHashPaymentIdZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_PaymentHashPaymentIdZ)); }
+	operator LDKC2Tuple_PaymentHashPaymentIdZ() && { LDKC2Tuple_PaymentHashPaymentIdZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_PaymentHashPaymentIdZ)); return res; }
+	~C2Tuple_PaymentHashPaymentIdZ() { C2Tuple_PaymentHashPaymentIdZ_free(self); }
+	C2Tuple_PaymentHashPaymentIdZ& operator=(C2Tuple_PaymentHashPaymentIdZ&& o) { C2Tuple_PaymentHashPaymentIdZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_PaymentHashPaymentIdZ)); return *this; }
+	LDKC2Tuple_PaymentHashPaymentIdZ* operator &() { return &self; }
+	LDKC2Tuple_PaymentHashPaymentIdZ* operator ->() { return &self; }
+	const LDKC2Tuple_PaymentHashPaymentIdZ* operator &() const { return &self; }
+	const LDKC2Tuple_PaymentHashPaymentIdZ* operator ->() const { return &self; }
+};
+class CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ {
+private:
+	LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ self;
+public:
+	CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ(const CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ&) = delete;
+	CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ(CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ)); }
+	CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ)); }
+	operator LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ() && { LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ)); return res; }
+	~CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ() { CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(self); }
+	CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ& operator=(CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ&& o) { CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ)); return *this; }
+	LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* operator &() { return &self; }
+	LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* operator ->() { return &self; }
+	const LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* operator &() const { return &self; }
+	const LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* operator ->() const { return &self; }
+};
+class CResult_NoneErrorZ {
+private:
+	LDKCResult_NoneErrorZ self;
+public:
+	CResult_NoneErrorZ(const CResult_NoneErrorZ&) = delete;
+	CResult_NoneErrorZ(CResult_NoneErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneErrorZ)); }
+	CResult_NoneErrorZ(LDKCResult_NoneErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneErrorZ)); }
+	operator LDKCResult_NoneErrorZ() && { LDKCResult_NoneErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneErrorZ)); return res; }
+	~CResult_NoneErrorZ() { CResult_NoneErrorZ_free(self); }
+	CResult_NoneErrorZ& operator=(CResult_NoneErrorZ&& o) { CResult_NoneErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneErrorZ)); return *this; }
+	LDKCResult_NoneErrorZ* operator &() { return &self; }
+	LDKCResult_NoneErrorZ* operator ->() { return &self; }
+	const LDKCResult_NoneErrorZ* operator &() const { return &self; }
+	const LDKCResult_NoneErrorZ* 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_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_SiPrefixParseErrorZ {
+private:
+	LDKCResult_SiPrefixParseErrorZ self;
+public:
+	CResult_SiPrefixParseErrorZ(const CResult_SiPrefixParseErrorZ&) = delete;
+	CResult_SiPrefixParseErrorZ(CResult_SiPrefixParseErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SiPrefixParseErrorZ)); }
+	CResult_SiPrefixParseErrorZ(LDKCResult_SiPrefixParseErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SiPrefixParseErrorZ)); }
+	operator LDKCResult_SiPrefixParseErrorZ() && { LDKCResult_SiPrefixParseErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SiPrefixParseErrorZ)); return res; }
+	~CResult_SiPrefixParseErrorZ() { CResult_SiPrefixParseErrorZ_free(self); }
+	CResult_SiPrefixParseErrorZ& operator=(CResult_SiPrefixParseErrorZ&& o) { CResult_SiPrefixParseErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SiPrefixParseErrorZ)); return *this; }
+	LDKCResult_SiPrefixParseErrorZ* operator &() { return &self; }
+	LDKCResult_SiPrefixParseErrorZ* operator ->() { return &self; }
+	const LDKCResult_SiPrefixParseErrorZ* operator &() const { return &self; }
+	const LDKCResult_SiPrefixParseErrorZ* 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 CResult_TrustedCommitmentTransactionNoneZ {
+private:
+	LDKCResult_TrustedCommitmentTransactionNoneZ self;
+public:
+	CResult_TrustedCommitmentTransactionNoneZ(const CResult_TrustedCommitmentTransactionNoneZ&) = delete;
+	CResult_TrustedCommitmentTransactionNoneZ(CResult_TrustedCommitmentTransactionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TrustedCommitmentTransactionNoneZ)); }
+	CResult_TrustedCommitmentTransactionNoneZ(LDKCResult_TrustedCommitmentTransactionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ)); }
+	operator LDKCResult_TrustedCommitmentTransactionNoneZ() && { LDKCResult_TrustedCommitmentTransactionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ)); return res; }
+	~CResult_TrustedCommitmentTransactionNoneZ() { CResult_TrustedCommitmentTransactionNoneZ_free(self); }
+	CResult_TrustedCommitmentTransactionNoneZ& operator=(CResult_TrustedCommitmentTransactionNoneZ&& o) { CResult_TrustedCommitmentTransactionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TrustedCommitmentTransactionNoneZ)); return *this; }
+	LDKCResult_TrustedCommitmentTransactionNoneZ* operator &() { return &self; }
+	LDKCResult_TrustedCommitmentTransactionNoneZ* operator ->() { return &self; }
+	const LDKCResult_TrustedCommitmentTransactionNoneZ* operator &() const { return &self; }
+	const LDKCResult_TrustedCommitmentTransactionNoneZ* operator ->() const { return &self; }
+};
+class CResult_FixedPenaltyScorerDecodeErrorZ {
+private:
+	LDKCResult_FixedPenaltyScorerDecodeErrorZ self;
+public:
+	CResult_FixedPenaltyScorerDecodeErrorZ(const CResult_FixedPenaltyScorerDecodeErrorZ&) = delete;
+	CResult_FixedPenaltyScorerDecodeErrorZ(CResult_FixedPenaltyScorerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FixedPenaltyScorerDecodeErrorZ)); }
+	CResult_FixedPenaltyScorerDecodeErrorZ(LDKCResult_FixedPenaltyScorerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ)); }
+	operator LDKCResult_FixedPenaltyScorerDecodeErrorZ() && { LDKCResult_FixedPenaltyScorerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ)); return res; }
+	~CResult_FixedPenaltyScorerDecodeErrorZ() { CResult_FixedPenaltyScorerDecodeErrorZ_free(self); }
+	CResult_FixedPenaltyScorerDecodeErrorZ& operator=(CResult_FixedPenaltyScorerDecodeErrorZ&& o) { CResult_FixedPenaltyScorerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FixedPenaltyScorerDecodeErrorZ)); return *this; }
+	LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_NoneLightningErrorZ {
+private:
+	LDKCResult_NoneLightningErrorZ self;
+public:
+	CResult_NoneLightningErrorZ(const CResult_NoneLightningErrorZ&) = delete;
+	CResult_NoneLightningErrorZ(CResult_NoneLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneLightningErrorZ)); }
+	CResult_NoneLightningErrorZ(LDKCResult_NoneLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneLightningErrorZ)); }
+	operator LDKCResult_NoneLightningErrorZ() && { LDKCResult_NoneLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneLightningErrorZ)); return res; }
+	~CResult_NoneLightningErrorZ() { CResult_NoneLightningErrorZ_free(self); }
+	CResult_NoneLightningErrorZ& operator=(CResult_NoneLightningErrorZ&& o) { CResult_NoneLightningErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneLightningErrorZ)); return *this; }
+	LDKCResult_NoneLightningErrorZ* operator &() { return &self; }
+	LDKCResult_NoneLightningErrorZ* operator ->() { return &self; }
+	const LDKCResult_NoneLightningErrorZ* operator &() const { return &self; }
+	const LDKCResult_NoneLightningErrorZ* operator ->() const { return &self; }
+};
+class CResult_PaymentHashRetryableSendFailureZ {
+private:
+	LDKCResult_PaymentHashRetryableSendFailureZ self;
+public:
+	CResult_PaymentHashRetryableSendFailureZ(const CResult_PaymentHashRetryableSendFailureZ&) = delete;
+	CResult_PaymentHashRetryableSendFailureZ(CResult_PaymentHashRetryableSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentHashRetryableSendFailureZ)); }
+	CResult_PaymentHashRetryableSendFailureZ(LDKCResult_PaymentHashRetryableSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentHashRetryableSendFailureZ)); }
+	operator LDKCResult_PaymentHashRetryableSendFailureZ() && { LDKCResult_PaymentHashRetryableSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentHashRetryableSendFailureZ)); return res; }
+	~CResult_PaymentHashRetryableSendFailureZ() { CResult_PaymentHashRetryableSendFailureZ_free(self); }
+	CResult_PaymentHashRetryableSendFailureZ& operator=(CResult_PaymentHashRetryableSendFailureZ&& o) { CResult_PaymentHashRetryableSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentHashRetryableSendFailureZ)); return *this; }
+	LDKCResult_PaymentHashRetryableSendFailureZ* operator &() { return &self; }
+	LDKCResult_PaymentHashRetryableSendFailureZ* operator ->() { return &self; }
+	const LDKCResult_PaymentHashRetryableSendFailureZ* operator &() const { return &self; }
+	const LDKCResult_PaymentHashRetryableSendFailureZ* operator ->() const { return &self; }
+};
+class C2Tuple_PublicKeyCOption_NetAddressZZ {
+private:
+	LDKC2Tuple_PublicKeyCOption_NetAddressZZ self;
+public:
+	C2Tuple_PublicKeyCOption_NetAddressZZ(const C2Tuple_PublicKeyCOption_NetAddressZZ&) = delete;
+	C2Tuple_PublicKeyCOption_NetAddressZZ(C2Tuple_PublicKeyCOption_NetAddressZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_PublicKeyCOption_NetAddressZZ)); }
+	C2Tuple_PublicKeyCOption_NetAddressZZ(LDKC2Tuple_PublicKeyCOption_NetAddressZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_PublicKeyCOption_NetAddressZZ)); }
+	operator LDKC2Tuple_PublicKeyCOption_NetAddressZZ() && { LDKC2Tuple_PublicKeyCOption_NetAddressZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_PublicKeyCOption_NetAddressZZ)); return res; }
+	~C2Tuple_PublicKeyCOption_NetAddressZZ() { C2Tuple_PublicKeyCOption_NetAddressZZ_free(self); }
+	C2Tuple_PublicKeyCOption_NetAddressZZ& operator=(C2Tuple_PublicKeyCOption_NetAddressZZ&& o) { C2Tuple_PublicKeyCOption_NetAddressZZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_PublicKeyCOption_NetAddressZZ)); return *this; }
+	LDKC2Tuple_PublicKeyCOption_NetAddressZZ* operator &() { return &self; }
+	LDKC2Tuple_PublicKeyCOption_NetAddressZZ* operator ->() { return &self; }
+	const LDKC2Tuple_PublicKeyCOption_NetAddressZZ* operator &() const { return &self; }
+	const LDKC2Tuple_PublicKeyCOption_NetAddressZZ* operator ->() const { return &self; }
+};
+class CResult_COption_EventZDecodeErrorZ {
+private:
+	LDKCResult_COption_EventZDecodeErrorZ self;
+public:
+	CResult_COption_EventZDecodeErrorZ(const CResult_COption_EventZDecodeErrorZ&) = delete;
+	CResult_COption_EventZDecodeErrorZ(CResult_COption_EventZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_EventZDecodeErrorZ)); }
+	CResult_COption_EventZDecodeErrorZ(LDKCResult_COption_EventZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_EventZDecodeErrorZ)); }
+	operator LDKCResult_COption_EventZDecodeErrorZ() && { LDKCResult_COption_EventZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_EventZDecodeErrorZ)); return res; }
+	~CResult_COption_EventZDecodeErrorZ() { CResult_COption_EventZDecodeErrorZ_free(self); }
+	CResult_COption_EventZDecodeErrorZ& operator=(CResult_COption_EventZDecodeErrorZ&& o) { CResult_COption_EventZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_EventZDecodeErrorZ)); return *this; }
+	LDKCResult_COption_EventZDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_COption_EventZDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_COption_EventZDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_COption_EventZDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_CVec_SignatureZNoneZ {
+private:
+	LDKCResult_CVec_SignatureZNoneZ self;
+public:
+	CResult_CVec_SignatureZNoneZ(const CResult_CVec_SignatureZNoneZ&) = delete;
+	CResult_CVec_SignatureZNoneZ(CResult_CVec_SignatureZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_SignatureZNoneZ)); }
+	CResult_CVec_SignatureZNoneZ(LDKCResult_CVec_SignatureZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_SignatureZNoneZ)); }
+	operator LDKCResult_CVec_SignatureZNoneZ() && { LDKCResult_CVec_SignatureZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_SignatureZNoneZ)); return res; }
+	~CResult_CVec_SignatureZNoneZ() { CResult_CVec_SignatureZNoneZ_free(self); }
+	CResult_CVec_SignatureZNoneZ& operator=(CResult_CVec_SignatureZNoneZ&& o) { CResult_CVec_SignatureZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_SignatureZNoneZ)); return *this; }
+	LDKCResult_CVec_SignatureZNoneZ* operator &() { return &self; }
+	LDKCResult_CVec_SignatureZNoneZ* operator ->() { return &self; }
+	const LDKCResult_CVec_SignatureZNoneZ* operator &() const { return &self; }
+	const LDKCResult_CVec_SignatureZNoneZ* operator ->() const { return &self; }
+};
+class COption_CVec_NetAddressZZ {
+private:
+	LDKCOption_CVec_NetAddressZZ self;
+public:
+	COption_CVec_NetAddressZZ(const COption_CVec_NetAddressZZ&) = delete;
+	COption_CVec_NetAddressZZ(COption_CVec_NetAddressZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_CVec_NetAddressZZ)); }
+	COption_CVec_NetAddressZZ(LDKCOption_CVec_NetAddressZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_CVec_NetAddressZZ)); }
+	operator LDKCOption_CVec_NetAddressZZ() && { LDKCOption_CVec_NetAddressZZ res = self; memset(&self, 0, sizeof(LDKCOption_CVec_NetAddressZZ)); return res; }
+	~COption_CVec_NetAddressZZ() { COption_CVec_NetAddressZZ_free(self); }
+	COption_CVec_NetAddressZZ& operator=(COption_CVec_NetAddressZZ&& o) { COption_CVec_NetAddressZZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_CVec_NetAddressZZ)); return *this; }
+	LDKCOption_CVec_NetAddressZZ* operator &() { return &self; }
+	LDKCOption_CVec_NetAddressZZ* operator ->() { return &self; }
+	const LDKCOption_CVec_NetAddressZZ* operator &() const { return &self; }
+	const LDKCOption_CVec_NetAddressZZ* operator ->() const { return &self; }
+};
+class CResult_NonePeerHandleErrorZ {
+private:
+	LDKCResult_NonePeerHandleErrorZ self;
+public:
+	CResult_NonePeerHandleErrorZ(const CResult_NonePeerHandleErrorZ&) = delete;
+	CResult_NonePeerHandleErrorZ(CResult_NonePeerHandleErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NonePeerHandleErrorZ)); }
+	CResult_NonePeerHandleErrorZ(LDKCResult_NonePeerHandleErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NonePeerHandleErrorZ)); }
+	operator LDKCResult_NonePeerHandleErrorZ() && { LDKCResult_NonePeerHandleErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NonePeerHandleErrorZ)); return res; }
+	~CResult_NonePeerHandleErrorZ() { CResult_NonePeerHandleErrorZ_free(self); }
+	CResult_NonePeerHandleErrorZ& operator=(CResult_NonePeerHandleErrorZ&& o) { CResult_NonePeerHandleErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NonePeerHandleErrorZ)); return *this; }
+	LDKCResult_NonePeerHandleErrorZ* operator &() { return &self; }
+	LDKCResult_NonePeerHandleErrorZ* operator ->() { return &self; }
+	const LDKCResult_NonePeerHandleErrorZ* operator &() const { return &self; }
+	const LDKCResult_NonePeerHandleErrorZ* operator ->() const { return &self; }
+};
+class CResult__u832APIErrorZ {
+private:
+	LDKCResult__u832APIErrorZ self;
+public:
+	CResult__u832APIErrorZ(const CResult__u832APIErrorZ&) = delete;
+	CResult__u832APIErrorZ(CResult__u832APIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult__u832APIErrorZ)); }
+	CResult__u832APIErrorZ(LDKCResult__u832APIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult__u832APIErrorZ)); }
+	operator LDKCResult__u832APIErrorZ() && { LDKCResult__u832APIErrorZ res = self; memset(&self, 0, sizeof(LDKCResult__u832APIErrorZ)); return res; }
+	~CResult__u832APIErrorZ() { CResult__u832APIErrorZ_free(self); }
+	CResult__u832APIErrorZ& operator=(CResult__u832APIErrorZ&& o) { CResult__u832APIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult__u832APIErrorZ)); return *this; }
+	LDKCResult__u832APIErrorZ* operator &() { return &self; }
+	LDKCResult__u832APIErrorZ* operator ->() { return &self; }
+	const LDKCResult__u832APIErrorZ* operator &() const { return &self; }
+	const LDKCResult__u832APIErrorZ* operator ->() const { return &self; }
+};
+class CResult_PaymentIdPaymentErrorZ {
+private:
+	LDKCResult_PaymentIdPaymentErrorZ self;
+public:
+	CResult_PaymentIdPaymentErrorZ(const CResult_PaymentIdPaymentErrorZ&) = delete;
+	CResult_PaymentIdPaymentErrorZ(CResult_PaymentIdPaymentErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentIdPaymentErrorZ)); }
+	CResult_PaymentIdPaymentErrorZ(LDKCResult_PaymentIdPaymentErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentIdPaymentErrorZ)); }
+	operator LDKCResult_PaymentIdPaymentErrorZ() && { LDKCResult_PaymentIdPaymentErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentIdPaymentErrorZ)); return res; }
+	~CResult_PaymentIdPaymentErrorZ() { CResult_PaymentIdPaymentErrorZ_free(self); }
+	CResult_PaymentIdPaymentErrorZ& operator=(CResult_PaymentIdPaymentErrorZ&& o) { CResult_PaymentIdPaymentErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentIdPaymentErrorZ)); return *this; }
+	LDKCResult_PaymentIdPaymentErrorZ* operator &() { return &self; }
+	LDKCResult_PaymentIdPaymentErrorZ* operator ->() { return &self; }
+	const LDKCResult_PaymentIdPaymentErrorZ* operator &() const { return &self; }
+	const LDKCResult_PaymentIdPaymentErrorZ* operator ->() const { return &self; }
+};
+class CResult_COption_MonitorEventZDecodeErrorZ {
+private:
+	LDKCResult_COption_MonitorEventZDecodeErrorZ self;
+public:
+	CResult_COption_MonitorEventZDecodeErrorZ(const CResult_COption_MonitorEventZDecodeErrorZ&) = delete;
+	CResult_COption_MonitorEventZDecodeErrorZ(CResult_COption_MonitorEventZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_MonitorEventZDecodeErrorZ)); }
+	CResult_COption_MonitorEventZDecodeErrorZ(LDKCResult_COption_MonitorEventZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ)); }
+	operator LDKCResult_COption_MonitorEventZDecodeErrorZ() && { LDKCResult_COption_MonitorEventZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ)); return res; }
+	~CResult_COption_MonitorEventZDecodeErrorZ() { CResult_COption_MonitorEventZDecodeErrorZ_free(self); }
+	CResult_COption_MonitorEventZDecodeErrorZ& operator=(CResult_COption_MonitorEventZDecodeErrorZ&& o) { CResult_COption_MonitorEventZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_MonitorEventZDecodeErrorZ)); return *this; }
+	LDKCResult_COption_MonitorEventZDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_COption_MonitorEventZDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_COption_MonitorEventZDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_COption_MonitorEventZDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_RoutingFeesDecodeErrorZ {
+private:
+	LDKCResult_RoutingFeesDecodeErrorZ self;
+public:
+	CResult_RoutingFeesDecodeErrorZ(const CResult_RoutingFeesDecodeErrorZ&) = delete;
+	CResult_RoutingFeesDecodeErrorZ(CResult_RoutingFeesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RoutingFeesDecodeErrorZ)); }
+	CResult_RoutingFeesDecodeErrorZ(LDKCResult_RoutingFeesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RoutingFeesDecodeErrorZ)); }
+	operator LDKCResult_RoutingFeesDecodeErrorZ() && { LDKCResult_RoutingFeesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RoutingFeesDecodeErrorZ)); return res; }
+	~CResult_RoutingFeesDecodeErrorZ() { CResult_RoutingFeesDecodeErrorZ_free(self); }
+	CResult_RoutingFeesDecodeErrorZ& operator=(CResult_RoutingFeesDecodeErrorZ&& o) { CResult_RoutingFeesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RoutingFeesDecodeErrorZ)); return *this; }
+	LDKCResult_RoutingFeesDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_RoutingFeesDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_RoutingFeesDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_RoutingFeesDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_PayeePubKeyErrorZ {
+private:
+	LDKCResult_PayeePubKeyErrorZ self;
+public:
+	CResult_PayeePubKeyErrorZ(const CResult_PayeePubKeyErrorZ&) = delete;
+	CResult_PayeePubKeyErrorZ(CResult_PayeePubKeyErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PayeePubKeyErrorZ)); }
+	CResult_PayeePubKeyErrorZ(LDKCResult_PayeePubKeyErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PayeePubKeyErrorZ)); }
+	operator LDKCResult_PayeePubKeyErrorZ() && { LDKCResult_PayeePubKeyErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PayeePubKeyErrorZ)); return res; }
+	~CResult_PayeePubKeyErrorZ() { CResult_PayeePubKeyErrorZ_free(self); }
+	CResult_PayeePubKeyErrorZ& operator=(CResult_PayeePubKeyErrorZ&& o) { CResult_PayeePubKeyErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PayeePubKeyErrorZ)); return *this; }
+	LDKCResult_PayeePubKeyErrorZ* operator &() { return &self; }
+	LDKCResult_PayeePubKeyErrorZ* operator ->() { return &self; }
+	const LDKCResult_PayeePubKeyErrorZ* operator &() const { return &self; }
+	const LDKCResult_PayeePubKeyErrorZ* operator ->() const { return &self; }
+};
+class CResult_DescriptionCreationErrorZ {
+private:
+	LDKCResult_DescriptionCreationErrorZ self;
+public:
+	CResult_DescriptionCreationErrorZ(const CResult_DescriptionCreationErrorZ&) = delete;
+	CResult_DescriptionCreationErrorZ(CResult_DescriptionCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_DescriptionCreationErrorZ)); }
+	CResult_DescriptionCreationErrorZ(LDKCResult_DescriptionCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_DescriptionCreationErrorZ)); }
+	operator LDKCResult_DescriptionCreationErrorZ() && { LDKCResult_DescriptionCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_DescriptionCreationErrorZ)); return res; }
+	~CResult_DescriptionCreationErrorZ() { CResult_DescriptionCreationErrorZ_free(self); }
+	CResult_DescriptionCreationErrorZ& operator=(CResult_DescriptionCreationErrorZ&& o) { CResult_DescriptionCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_DescriptionCreationErrorZ)); return *this; }
+	LDKCResult_DescriptionCreationErrorZ* operator &() { return &self; }
+	LDKCResult_DescriptionCreationErrorZ* operator ->() { return &self; }
+	const LDKCResult_DescriptionCreationErrorZ* operator &() const { return &self; }
+	const LDKCResult_DescriptionCreationErrorZ* 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_InvoiceSemanticErrorZ {
+private:
+	LDKCResult_InvoiceSemanticErrorZ self;
+public:
+	CResult_InvoiceSemanticErrorZ(const CResult_InvoiceSemanticErrorZ&) = delete;
+	CResult_InvoiceSemanticErrorZ(CResult_InvoiceSemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceSemanticErrorZ)); }
+	CResult_InvoiceSemanticErrorZ(LDKCResult_InvoiceSemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceSemanticErrorZ)); }
+	operator LDKCResult_InvoiceSemanticErrorZ() && { LDKCResult_InvoiceSemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceSemanticErrorZ)); return res; }
+	~CResult_InvoiceSemanticErrorZ() { CResult_InvoiceSemanticErrorZ_free(self); }
+	CResult_InvoiceSemanticErrorZ& operator=(CResult_InvoiceSemanticErrorZ&& o) { CResult_InvoiceSemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceSemanticErrorZ)); return *this; }
+	LDKCResult_InvoiceSemanticErrorZ* operator &() { return &self; }
+	LDKCResult_InvoiceSemanticErrorZ* operator ->() { return &self; }
+	const LDKCResult_InvoiceSemanticErrorZ* operator &() const { return &self; }
+	const LDKCResult_InvoiceSemanticErrorZ* operator ->() const { return &self; }
+};
+class CResult_UpdateAddHTLCDecodeErrorZ {
+private:
+	LDKCResult_UpdateAddHTLCDecodeErrorZ self;
+public:
+	CResult_UpdateAddHTLCDecodeErrorZ(const CResult_UpdateAddHTLCDecodeErrorZ&) = delete;
+	CResult_UpdateAddHTLCDecodeErrorZ(CResult_UpdateAddHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateAddHTLCDecodeErrorZ)); }
+	CResult_UpdateAddHTLCDecodeErrorZ(LDKCResult_UpdateAddHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ)); }
+	operator LDKCResult_UpdateAddHTLCDecodeErrorZ() && { LDKCResult_UpdateAddHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ)); return res; }
+	~CResult_UpdateAddHTLCDecodeErrorZ() { CResult_UpdateAddHTLCDecodeErrorZ_free(self); }
+	CResult_UpdateAddHTLCDecodeErrorZ& operator=(CResult_UpdateAddHTLCDecodeErrorZ&& o) { CResult_UpdateAddHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateAddHTLCDecodeErrorZ)); return *this; }
+	LDKCResult_UpdateAddHTLCDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_UpdateAddHTLCDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_UpdateAddHTLCDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_UpdateAddHTLCDecodeErrorZ* operator ->() const { return &self; }
+};
+class COption_MonitorEventZ {
+private:
+	LDKCOption_MonitorEventZ self;
+public:
+	COption_MonitorEventZ(const COption_MonitorEventZ&) = delete;
+	COption_MonitorEventZ(COption_MonitorEventZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_MonitorEventZ)); }
+	COption_MonitorEventZ(LDKCOption_MonitorEventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_MonitorEventZ)); }
+	operator LDKCOption_MonitorEventZ() && { LDKCOption_MonitorEventZ res = self; memset(&self, 0, sizeof(LDKCOption_MonitorEventZ)); return res; }
+	~COption_MonitorEventZ() { COption_MonitorEventZ_free(self); }
+	COption_MonitorEventZ& operator=(COption_MonitorEventZ&& o) { COption_MonitorEventZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_MonitorEventZ)); return *this; }
+	LDKCOption_MonitorEventZ* operator &() { return &self; }
+	LDKCOption_MonitorEventZ* operator ->() { return &self; }
+	const LDKCOption_MonitorEventZ* operator &() const { return &self; }
+	const LDKCOption_MonitorEventZ* operator ->() const { return &self; }
+};
+class COption_TypeZ {
+private:
+	LDKCOption_TypeZ self;
+public:
+	COption_TypeZ(const COption_TypeZ&) = delete;
+	COption_TypeZ(COption_TypeZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_TypeZ)); }
+	COption_TypeZ(LDKCOption_TypeZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_TypeZ)); }
+	operator LDKCOption_TypeZ() && { LDKCOption_TypeZ res = self; memset(&self, 0, sizeof(LDKCOption_TypeZ)); return res; }
+	~COption_TypeZ() { COption_TypeZ_free(self); }
+	COption_TypeZ& operator=(COption_TypeZ&& o) { COption_TypeZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_TypeZ)); return *this; }
+	LDKCOption_TypeZ* operator &() { return &self; }
+	LDKCOption_TypeZ* operator ->() { return &self; }
+	const LDKCOption_TypeZ* operator &() const { return &self; }
+	const LDKCOption_TypeZ* operator ->() const { return &self; }
+};
+class CResult_COption_TypeZDecodeErrorZ {
+private:
+	LDKCResult_COption_TypeZDecodeErrorZ self;
+public:
+	CResult_COption_TypeZDecodeErrorZ(const CResult_COption_TypeZDecodeErrorZ&) = delete;
+	CResult_COption_TypeZDecodeErrorZ(CResult_COption_TypeZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_TypeZDecodeErrorZ)); }
+	CResult_COption_TypeZDecodeErrorZ(LDKCResult_COption_TypeZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_TypeZDecodeErrorZ)); }
+	operator LDKCResult_COption_TypeZDecodeErrorZ() && { LDKCResult_COption_TypeZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_TypeZDecodeErrorZ)); return res; }
+	~CResult_COption_TypeZDecodeErrorZ() { CResult_COption_TypeZDecodeErrorZ_free(self); }
+	CResult_COption_TypeZDecodeErrorZ& operator=(CResult_COption_TypeZDecodeErrorZ&& o) { CResult_COption_TypeZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_TypeZDecodeErrorZ)); return *this; }
+	LDKCResult_COption_TypeZDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_COption_TypeZDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_COption_TypeZDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_COption_TypeZDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_COption_PathFailureZDecodeErrorZ {
+private:
+	LDKCResult_COption_PathFailureZDecodeErrorZ self;
+public:
+	CResult_COption_PathFailureZDecodeErrorZ(const CResult_COption_PathFailureZDecodeErrorZ&) = delete;
+	CResult_COption_PathFailureZDecodeErrorZ(CResult_COption_PathFailureZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_PathFailureZDecodeErrorZ)); }
+	CResult_COption_PathFailureZDecodeErrorZ(LDKCResult_COption_PathFailureZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_PathFailureZDecodeErrorZ)); }
+	operator LDKCResult_COption_PathFailureZDecodeErrorZ() && { LDKCResult_COption_PathFailureZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_PathFailureZDecodeErrorZ)); return res; }
+	~CResult_COption_PathFailureZDecodeErrorZ() { CResult_COption_PathFailureZDecodeErrorZ_free(self); }
+	CResult_COption_PathFailureZDecodeErrorZ& operator=(CResult_COption_PathFailureZDecodeErrorZ&& o) { CResult_COption_PathFailureZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_PathFailureZDecodeErrorZ)); return *this; }
+	LDKCResult_COption_PathFailureZDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_COption_PathFailureZDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_COption_PathFailureZDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_COption_PathFailureZDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_UpdateFailHTLCDecodeErrorZ {
+private:
+	LDKCResult_UpdateFailHTLCDecodeErrorZ self;
+public:
+	CResult_UpdateFailHTLCDecodeErrorZ(const CResult_UpdateFailHTLCDecodeErrorZ&) = delete;
+	CResult_UpdateFailHTLCDecodeErrorZ(CResult_UpdateFailHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateFailHTLCDecodeErrorZ)); }
+	CResult_UpdateFailHTLCDecodeErrorZ(LDKCResult_UpdateFailHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ)); }
+	operator LDKCResult_UpdateFailHTLCDecodeErrorZ() && { LDKCResult_UpdateFailHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ)); return res; }
+	~CResult_UpdateFailHTLCDecodeErrorZ() { CResult_UpdateFailHTLCDecodeErrorZ_free(self); }
+	CResult_UpdateFailHTLCDecodeErrorZ& operator=(CResult_UpdateFailHTLCDecodeErrorZ&& o) { CResult_UpdateFailHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateFailHTLCDecodeErrorZ)); return *this; }
+	LDKCResult_UpdateFailHTLCDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_UpdateFailHTLCDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_UpdateFailHTLCDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_UpdateFailHTLCDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_InvoiceParseOrSemanticErrorZ {
+private:
+	LDKCResult_InvoiceParseOrSemanticErrorZ self;
+public:
+	CResult_InvoiceParseOrSemanticErrorZ(const CResult_InvoiceParseOrSemanticErrorZ&) = delete;
+	CResult_InvoiceParseOrSemanticErrorZ(CResult_InvoiceParseOrSemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceParseOrSemanticErrorZ)); }
+	CResult_InvoiceParseOrSemanticErrorZ(LDKCResult_InvoiceParseOrSemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceParseOrSemanticErrorZ)); }
+	operator LDKCResult_InvoiceParseOrSemanticErrorZ() && { LDKCResult_InvoiceParseOrSemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceParseOrSemanticErrorZ)); return res; }
+	~CResult_InvoiceParseOrSemanticErrorZ() { CResult_InvoiceParseOrSemanticErrorZ_free(self); }
+	CResult_InvoiceParseOrSemanticErrorZ& operator=(CResult_InvoiceParseOrSemanticErrorZ&& o) { CResult_InvoiceParseOrSemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceParseOrSemanticErrorZ)); return *this; }
+	LDKCResult_InvoiceParseOrSemanticErrorZ* operator &() { return &self; }
+	LDKCResult_InvoiceParseOrSemanticErrorZ* operator ->() { return &self; }
+	const LDKCResult_InvoiceParseOrSemanticErrorZ* operator &() const { return &self; }
+	const LDKCResult_InvoiceParseOrSemanticErrorZ* operator ->() const { return &self; }
+};
+class CResult_RevokeAndACKDecodeErrorZ {
+private:
+	LDKCResult_RevokeAndACKDecodeErrorZ self;
+public:
+	CResult_RevokeAndACKDecodeErrorZ(const CResult_RevokeAndACKDecodeErrorZ&) = delete;
+	CResult_RevokeAndACKDecodeErrorZ(CResult_RevokeAndACKDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RevokeAndACKDecodeErrorZ)); }
+	CResult_RevokeAndACKDecodeErrorZ(LDKCResult_RevokeAndACKDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RevokeAndACKDecodeErrorZ)); }
+	operator LDKCResult_RevokeAndACKDecodeErrorZ() && { LDKCResult_RevokeAndACKDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RevokeAndACKDecodeErrorZ)); return res; }
+	~CResult_RevokeAndACKDecodeErrorZ() { CResult_RevokeAndACKDecodeErrorZ_free(self); }
+	CResult_RevokeAndACKDecodeErrorZ& operator=(CResult_RevokeAndACKDecodeErrorZ&& o) { CResult_RevokeAndACKDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RevokeAndACKDecodeErrorZ)); return *this; }
+	LDKCResult_RevokeAndACKDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_RevokeAndACKDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_RevokeAndACKDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_RevokeAndACKDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_SpendableOutputDescriptorDecodeErrorZ {
+private:
+	LDKCResult_SpendableOutputDescriptorDecodeErrorZ self;
+public:
+	CResult_SpendableOutputDescriptorDecodeErrorZ(const CResult_SpendableOutputDescriptorDecodeErrorZ&) = delete;
+	CResult_SpendableOutputDescriptorDecodeErrorZ(CResult_SpendableOutputDescriptorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SpendableOutputDescriptorDecodeErrorZ)); }
+	CResult_SpendableOutputDescriptorDecodeErrorZ(LDKCResult_SpendableOutputDescriptorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ)); }
+	operator LDKCResult_SpendableOutputDescriptorDecodeErrorZ() && { LDKCResult_SpendableOutputDescriptorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ)); return res; }
+	~CResult_SpendableOutputDescriptorDecodeErrorZ() { CResult_SpendableOutputDescriptorDecodeErrorZ_free(self); }
+	CResult_SpendableOutputDescriptorDecodeErrorZ& operator=(CResult_SpendableOutputDescriptorDecodeErrorZ&& o) { CResult_SpendableOutputDescriptorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SpendableOutputDescriptorDecodeErrorZ)); return *this; }
+	LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_UnsignedChannelUpdateDecodeErrorZ {
+private:
+	LDKCResult_UnsignedChannelUpdateDecodeErrorZ self;
+public:
+	CResult_UnsignedChannelUpdateDecodeErrorZ(const CResult_UnsignedChannelUpdateDecodeErrorZ&) = delete;
+	CResult_UnsignedChannelUpdateDecodeErrorZ(CResult_UnsignedChannelUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnsignedChannelUpdateDecodeErrorZ)); }
+	CResult_UnsignedChannelUpdateDecodeErrorZ(LDKCResult_UnsignedChannelUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ)); }
+	operator LDKCResult_UnsignedChannelUpdateDecodeErrorZ() && { LDKCResult_UnsignedChannelUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ)); return res; }
+	~CResult_UnsignedChannelUpdateDecodeErrorZ() { CResult_UnsignedChannelUpdateDecodeErrorZ_free(self); }
+	CResult_UnsignedChannelUpdateDecodeErrorZ& operator=(CResult_UnsignedChannelUpdateDecodeErrorZ&& o) { CResult_UnsignedChannelUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnsignedChannelUpdateDecodeErrorZ)); return *this; }
+	LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator ->() const { return &self; }
+};
+class CVec_EventZ {
+private:
+	LDKCVec_EventZ self;
+public:
+	CVec_EventZ(const CVec_EventZ&) = delete;
+	CVec_EventZ(CVec_EventZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_EventZ)); }
+	CVec_EventZ(LDKCVec_EventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_EventZ)); }
+	operator LDKCVec_EventZ() && { LDKCVec_EventZ res = self; memset(&self, 0, sizeof(LDKCVec_EventZ)); return res; }
+	~CVec_EventZ() { CVec_EventZ_free(self); }
+	CVec_EventZ& operator=(CVec_EventZ&& o) { CVec_EventZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_EventZ)); return *this; }
+	LDKCVec_EventZ* operator &() { return &self; }
+	LDKCVec_EventZ* operator ->() { return &self; }
+	const LDKCVec_EventZ* operator &() const { return &self; }
+	const LDKCVec_EventZ* operator ->() const { return &self; }
+};
+class CResult_NoneSemanticErrorZ {
+private:
+	LDKCResult_NoneSemanticErrorZ self;
+public:
+	CResult_NoneSemanticErrorZ(const CResult_NoneSemanticErrorZ&) = delete;
+	CResult_NoneSemanticErrorZ(CResult_NoneSemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneSemanticErrorZ)); }
+	CResult_NoneSemanticErrorZ(LDKCResult_NoneSemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneSemanticErrorZ)); }
+	operator LDKCResult_NoneSemanticErrorZ() && { LDKCResult_NoneSemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneSemanticErrorZ)); return res; }
+	~CResult_NoneSemanticErrorZ() { CResult_NoneSemanticErrorZ_free(self); }
+	CResult_NoneSemanticErrorZ& operator=(CResult_NoneSemanticErrorZ&& o) { CResult_NoneSemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneSemanticErrorZ)); return *this; }
+	LDKCResult_NoneSemanticErrorZ* operator &() { return &self; }
+	LDKCResult_NoneSemanticErrorZ* operator ->() { return &self; }
+	const LDKCResult_NoneSemanticErrorZ* operator &() const { return &self; }
+	const LDKCResult_NoneSemanticErrorZ* operator ->() const { return &self; }
+};
+class CVec_C2Tuple_u32ScriptZZ {
+private:
+	LDKCVec_C2Tuple_u32ScriptZZ self;
+public:
+	CVec_C2Tuple_u32ScriptZZ(const CVec_C2Tuple_u32ScriptZZ&) = delete;
+	CVec_C2Tuple_u32ScriptZZ(CVec_C2Tuple_u32ScriptZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_u32ScriptZZ)); }
+	CVec_C2Tuple_u32ScriptZZ(LDKCVec_C2Tuple_u32ScriptZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_u32ScriptZZ)); }
+	operator LDKCVec_C2Tuple_u32ScriptZZ() && { LDKCVec_C2Tuple_u32ScriptZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_u32ScriptZZ)); return res; }
+	~CVec_C2Tuple_u32ScriptZZ() { CVec_C2Tuple_u32ScriptZZ_free(self); }
+	CVec_C2Tuple_u32ScriptZZ& operator=(CVec_C2Tuple_u32ScriptZZ&& o) { CVec_C2Tuple_u32ScriptZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_u32ScriptZZ)); return *this; }
+	LDKCVec_C2Tuple_u32ScriptZZ* operator &() { return &self; }
+	LDKCVec_C2Tuple_u32ScriptZZ* operator ->() { return &self; }
+	const LDKCVec_C2Tuple_u32ScriptZZ* operator &() const { return &self; }
+	const LDKCVec_C2Tuple_u32ScriptZZ* operator ->() const { return &self; }
+};
+class CResult_COption_ClosureReasonZDecodeErrorZ {
+private:
+	LDKCResult_COption_ClosureReasonZDecodeErrorZ self;
+public:
+	CResult_COption_ClosureReasonZDecodeErrorZ(const CResult_COption_ClosureReasonZDecodeErrorZ&) = delete;
+	CResult_COption_ClosureReasonZDecodeErrorZ(CResult_COption_ClosureReasonZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_ClosureReasonZDecodeErrorZ)); }
+	CResult_COption_ClosureReasonZDecodeErrorZ(LDKCResult_COption_ClosureReasonZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ)); }
+	operator LDKCResult_COption_ClosureReasonZDecodeErrorZ() && { LDKCResult_COption_ClosureReasonZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ)); return res; }
+	~CResult_COption_ClosureReasonZDecodeErrorZ() { CResult_COption_ClosureReasonZDecodeErrorZ_free(self); }
+	CResult_COption_ClosureReasonZDecodeErrorZ& operator=(CResult_COption_ClosureReasonZDecodeErrorZ&& o) { CResult_COption_ClosureReasonZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_ClosureReasonZDecodeErrorZ)); return *this; }
+	LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_PaymentHashPaymentSendFailureZ {
+private:
+	LDKCResult_PaymentHashPaymentSendFailureZ self;
+public:
+	CResult_PaymentHashPaymentSendFailureZ(const CResult_PaymentHashPaymentSendFailureZ&) = delete;
+	CResult_PaymentHashPaymentSendFailureZ(CResult_PaymentHashPaymentSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentHashPaymentSendFailureZ)); }
+	CResult_PaymentHashPaymentSendFailureZ(LDKCResult_PaymentHashPaymentSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentHashPaymentSendFailureZ)); }
+	operator LDKCResult_PaymentHashPaymentSendFailureZ() && { LDKCResult_PaymentHashPaymentSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentHashPaymentSendFailureZ)); return res; }
+	~CResult_PaymentHashPaymentSendFailureZ() { CResult_PaymentHashPaymentSendFailureZ_free(self); }
+	CResult_PaymentHashPaymentSendFailureZ& operator=(CResult_PaymentHashPaymentSendFailureZ&& o) { CResult_PaymentHashPaymentSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentHashPaymentSendFailureZ)); return *this; }
+	LDKCResult_PaymentHashPaymentSendFailureZ* operator &() { return &self; }
+	LDKCResult_PaymentHashPaymentSendFailureZ* operator ->() { return &self; }
+	const LDKCResult_PaymentHashPaymentSendFailureZ* operator &() const { return &self; }
+	const LDKCResult_PaymentHashPaymentSendFailureZ* operator ->() const { return &self; }
+};
+class C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ {
+private:
+	LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ self;
+public:
+	C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(const C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&) = delete;
+	C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); }
+	C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); }
+	operator LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ() && { LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); return res; }
+	~C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ() { C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(self); }
+	C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ& operator=(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&& o) { C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(self); self = o.self; memset(&o, 0, sizeof(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); return *this; }
+	LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator &() { return &self; }
+	LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator ->() { return &self; }
+	const LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator &() const { return &self; }
+	const LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator ->() const { return &self; }
+};
+class CResult_RouteParametersDecodeErrorZ {
+private:
+	LDKCResult_RouteParametersDecodeErrorZ self;
+public:
+	CResult_RouteParametersDecodeErrorZ(const CResult_RouteParametersDecodeErrorZ&) = delete;
+	CResult_RouteParametersDecodeErrorZ(CResult_RouteParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteParametersDecodeErrorZ)); }
+	CResult_RouteParametersDecodeErrorZ(LDKCResult_RouteParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteParametersDecodeErrorZ)); }
+	operator LDKCResult_RouteParametersDecodeErrorZ() && { LDKCResult_RouteParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteParametersDecodeErrorZ)); return res; }
+	~CResult_RouteParametersDecodeErrorZ() { CResult_RouteParametersDecodeErrorZ_free(self); }
+	CResult_RouteParametersDecodeErrorZ& operator=(CResult_RouteParametersDecodeErrorZ&& o) { CResult_RouteParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteParametersDecodeErrorZ)); return *this; }
+	LDKCResult_RouteParametersDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_RouteParametersDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_RouteParametersDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_RouteParametersDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_PrivateRouteCreationErrorZ {
+private:
+	LDKCResult_PrivateRouteCreationErrorZ self;
+public:
+	CResult_PrivateRouteCreationErrorZ(const CResult_PrivateRouteCreationErrorZ&) = delete;
+	CResult_PrivateRouteCreationErrorZ(CResult_PrivateRouteCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PrivateRouteCreationErrorZ)); }
+	CResult_PrivateRouteCreationErrorZ(LDKCResult_PrivateRouteCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PrivateRouteCreationErrorZ)); }
+	operator LDKCResult_PrivateRouteCreationErrorZ() && { LDKCResult_PrivateRouteCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PrivateRouteCreationErrorZ)); return res; }
+	~CResult_PrivateRouteCreationErrorZ() { CResult_PrivateRouteCreationErrorZ_free(self); }
+	CResult_PrivateRouteCreationErrorZ& operator=(CResult_PrivateRouteCreationErrorZ&& o) { CResult_PrivateRouteCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PrivateRouteCreationErrorZ)); return *this; }
+	LDKCResult_PrivateRouteCreationErrorZ* operator &() { return &self; }
+	LDKCResult_PrivateRouteCreationErrorZ* operator ->() { return &self; }
+	const LDKCResult_PrivateRouteCreationErrorZ* operator &() const { return &self; }
+	const LDKCResult_PrivateRouteCreationErrorZ* operator ->() const { return &self; }
+};
+class CResult_NodeAliasDecodeErrorZ {
+private:
+	LDKCResult_NodeAliasDecodeErrorZ self;
+public:
+	CResult_NodeAliasDecodeErrorZ(const CResult_NodeAliasDecodeErrorZ&) = delete;
+	CResult_NodeAliasDecodeErrorZ(CResult_NodeAliasDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeAliasDecodeErrorZ)); }
+	CResult_NodeAliasDecodeErrorZ(LDKCResult_NodeAliasDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeAliasDecodeErrorZ)); }
+	operator LDKCResult_NodeAliasDecodeErrorZ() && { LDKCResult_NodeAliasDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeAliasDecodeErrorZ)); return res; }
+	~CResult_NodeAliasDecodeErrorZ() { CResult_NodeAliasDecodeErrorZ_free(self); }
+	CResult_NodeAliasDecodeErrorZ& operator=(CResult_NodeAliasDecodeErrorZ&& o) { CResult_NodeAliasDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeAliasDecodeErrorZ)); return *this; }
+	LDKCResult_NodeAliasDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_NodeAliasDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_NodeAliasDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_NodeAliasDecodeErrorZ* operator ->() const { return &self; }
+};
+class CVec_UpdateFulfillHTLCZ {
+private:
+	LDKCVec_UpdateFulfillHTLCZ self;
+public:
+	CVec_UpdateFulfillHTLCZ(const CVec_UpdateFulfillHTLCZ&) = delete;
+	CVec_UpdateFulfillHTLCZ(CVec_UpdateFulfillHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateFulfillHTLCZ)); }
+	CVec_UpdateFulfillHTLCZ(LDKCVec_UpdateFulfillHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateFulfillHTLCZ)); }
+	operator LDKCVec_UpdateFulfillHTLCZ() && { LDKCVec_UpdateFulfillHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateFulfillHTLCZ)); return res; }
+	~CVec_UpdateFulfillHTLCZ() { CVec_UpdateFulfillHTLCZ_free(self); }
+	CVec_UpdateFulfillHTLCZ& operator=(CVec_UpdateFulfillHTLCZ&& o) { CVec_UpdateFulfillHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateFulfillHTLCZ)); return *this; }
+	LDKCVec_UpdateFulfillHTLCZ* operator &() { return &self; }
+	LDKCVec_UpdateFulfillHTLCZ* operator ->() { return &self; }
+	const LDKCVec_UpdateFulfillHTLCZ* operator &() const { return &self; }
+	const LDKCVec_UpdateFulfillHTLCZ* operator ->() const { return &self; }
+};
+class CResult_AnnouncementSignaturesDecodeErrorZ {
+private:
+	LDKCResult_AnnouncementSignaturesDecodeErrorZ self;
+public:
+	CResult_AnnouncementSignaturesDecodeErrorZ(const CResult_AnnouncementSignaturesDecodeErrorZ&) = delete;
+	CResult_AnnouncementSignaturesDecodeErrorZ(CResult_AnnouncementSignaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_AnnouncementSignaturesDecodeErrorZ)); }
+	CResult_AnnouncementSignaturesDecodeErrorZ(LDKCResult_AnnouncementSignaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ)); }
+	operator LDKCResult_AnnouncementSignaturesDecodeErrorZ() && { LDKCResult_AnnouncementSignaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ)); return res; }
+	~CResult_AnnouncementSignaturesDecodeErrorZ() { CResult_AnnouncementSignaturesDecodeErrorZ_free(self); }
+	CResult_AnnouncementSignaturesDecodeErrorZ& operator=(CResult_AnnouncementSignaturesDecodeErrorZ&& o) { CResult_AnnouncementSignaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_AnnouncementSignaturesDecodeErrorZ)); return *this; }
+	LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_UpdateFulfillHTLCDecodeErrorZ {
+private:
+	LDKCResult_UpdateFulfillHTLCDecodeErrorZ self;
+public:
+	CResult_UpdateFulfillHTLCDecodeErrorZ(const CResult_UpdateFulfillHTLCDecodeErrorZ&) = delete;
+	CResult_UpdateFulfillHTLCDecodeErrorZ(CResult_UpdateFulfillHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateFulfillHTLCDecodeErrorZ)); }
+	CResult_UpdateFulfillHTLCDecodeErrorZ(LDKCResult_UpdateFulfillHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ)); }
+	operator LDKCResult_UpdateFulfillHTLCDecodeErrorZ() && { LDKCResult_UpdateFulfillHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ)); return res; }
+	~CResult_UpdateFulfillHTLCDecodeErrorZ() { CResult_UpdateFulfillHTLCDecodeErrorZ_free(self); }
+	CResult_UpdateFulfillHTLCDecodeErrorZ& operator=(CResult_UpdateFulfillHTLCDecodeErrorZ&& o) { CResult_UpdateFulfillHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateFulfillHTLCDecodeErrorZ)); return *this; }
+	LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_NodeFeaturesDecodeErrorZ {
+private:
+	LDKCResult_NodeFeaturesDecodeErrorZ self;
+public:
+	CResult_NodeFeaturesDecodeErrorZ(const CResult_NodeFeaturesDecodeErrorZ&) = delete;
+	CResult_NodeFeaturesDecodeErrorZ(CResult_NodeFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeFeaturesDecodeErrorZ)); }
+	CResult_NodeFeaturesDecodeErrorZ(LDKCResult_NodeFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeFeaturesDecodeErrorZ)); }
+	operator LDKCResult_NodeFeaturesDecodeErrorZ() && { LDKCResult_NodeFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeFeaturesDecodeErrorZ)); return res; }
+	~CResult_NodeFeaturesDecodeErrorZ() { CResult_NodeFeaturesDecodeErrorZ_free(self); }
+	CResult_NodeFeaturesDecodeErrorZ& operator=(CResult_NodeFeaturesDecodeErrorZ&& o) { CResult_NodeFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeFeaturesDecodeErrorZ)); return *this; }
+	LDKCResult_NodeFeaturesDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_NodeFeaturesDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_NodeFeaturesDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_NodeFeaturesDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_InMemorySignerDecodeErrorZ {
+private:
+	LDKCResult_InMemorySignerDecodeErrorZ self;
+public:
+	CResult_InMemorySignerDecodeErrorZ(const CResult_InMemorySignerDecodeErrorZ&) = delete;
+	CResult_InMemorySignerDecodeErrorZ(CResult_InMemorySignerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InMemorySignerDecodeErrorZ)); }
+	CResult_InMemorySignerDecodeErrorZ(LDKCResult_InMemorySignerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InMemorySignerDecodeErrorZ)); }
+	operator LDKCResult_InMemorySignerDecodeErrorZ() && { LDKCResult_InMemorySignerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InMemorySignerDecodeErrorZ)); return res; }
+	~CResult_InMemorySignerDecodeErrorZ() { CResult_InMemorySignerDecodeErrorZ_free(self); }
+	CResult_InMemorySignerDecodeErrorZ& operator=(CResult_InMemorySignerDecodeErrorZ&& o) { CResult_InMemorySignerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InMemorySignerDecodeErrorZ)); return *this; }
+	LDKCResult_InMemorySignerDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_InMemorySignerDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_InMemorySignerDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_InMemorySignerDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_ReplyShortChannelIdsEndDecodeErrorZ {
+private:
+	LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ self;
+public:
+	CResult_ReplyShortChannelIdsEndDecodeErrorZ(const CResult_ReplyShortChannelIdsEndDecodeErrorZ&) = delete;
+	CResult_ReplyShortChannelIdsEndDecodeErrorZ(CResult_ReplyShortChannelIdsEndDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ReplyShortChannelIdsEndDecodeErrorZ)); }
+	CResult_ReplyShortChannelIdsEndDecodeErrorZ(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ)); }
+	operator LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ() && { LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ)); return res; }
+	~CResult_ReplyShortChannelIdsEndDecodeErrorZ() { CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(self); }
+	CResult_ReplyShortChannelIdsEndDecodeErrorZ& operator=(CResult_ReplyShortChannelIdsEndDecodeErrorZ&& o) { CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ReplyShortChannelIdsEndDecodeErrorZ)); return *this; }
+	LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator ->() const { return &self; }
+};
+class COption_PathFailureZ {
+private:
+	LDKCOption_PathFailureZ self;
+public:
+	COption_PathFailureZ(const COption_PathFailureZ&) = delete;
+	COption_PathFailureZ(COption_PathFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_PathFailureZ)); }
+	COption_PathFailureZ(LDKCOption_PathFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_PathFailureZ)); }
+	operator LDKCOption_PathFailureZ() && { LDKCOption_PathFailureZ res = self; memset(&self, 0, sizeof(LDKCOption_PathFailureZ)); return res; }
+	~COption_PathFailureZ() { COption_PathFailureZ_free(self); }
+	COption_PathFailureZ& operator=(COption_PathFailureZ&& o) { COption_PathFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_PathFailureZ)); return *this; }
+	LDKCOption_PathFailureZ* operator &() { return &self; }
+	LDKCOption_PathFailureZ* operator ->() { return &self; }
+	const LDKCOption_PathFailureZ* operator &() const { return &self; }
+	const LDKCOption_PathFailureZ* 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_ChannelUpdateInfoDecodeErrorZ {
+private:
+	LDKCResult_ChannelUpdateInfoDecodeErrorZ self;
+public:
+	CResult_ChannelUpdateInfoDecodeErrorZ(const CResult_ChannelUpdateInfoDecodeErrorZ&) = delete;
+	CResult_ChannelUpdateInfoDecodeErrorZ(CResult_ChannelUpdateInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelUpdateInfoDecodeErrorZ)); }
+	CResult_ChannelUpdateInfoDecodeErrorZ(LDKCResult_ChannelUpdateInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ)); }
+	operator LDKCResult_ChannelUpdateInfoDecodeErrorZ() && { LDKCResult_ChannelUpdateInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ)); return res; }
+	~CResult_ChannelUpdateInfoDecodeErrorZ() { CResult_ChannelUpdateInfoDecodeErrorZ_free(self); }
+	CResult_ChannelUpdateInfoDecodeErrorZ& operator=(CResult_ChannelUpdateInfoDecodeErrorZ&& o) { CResult_ChannelUpdateInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelUpdateInfoDecodeErrorZ)); return *this; }
+	LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_BuiltCommitmentTransactionDecodeErrorZ {
+private:
+	LDKCResult_BuiltCommitmentTransactionDecodeErrorZ self;
+public:
+	CResult_BuiltCommitmentTransactionDecodeErrorZ(const CResult_BuiltCommitmentTransactionDecodeErrorZ&) = delete;
+	CResult_BuiltCommitmentTransactionDecodeErrorZ(CResult_BuiltCommitmentTransactionDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BuiltCommitmentTransactionDecodeErrorZ)); }
+	CResult_BuiltCommitmentTransactionDecodeErrorZ(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ)); }
+	operator LDKCResult_BuiltCommitmentTransactionDecodeErrorZ() && { LDKCResult_BuiltCommitmentTransactionDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ)); return res; }
+	~CResult_BuiltCommitmentTransactionDecodeErrorZ() { CResult_BuiltCommitmentTransactionDecodeErrorZ_free(self); }
+	CResult_BuiltCommitmentTransactionDecodeErrorZ& operator=(CResult_BuiltCommitmentTransactionDecodeErrorZ&& o) { CResult_BuiltCommitmentTransactionDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BuiltCommitmentTransactionDecodeErrorZ)); return *this; }
+	LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ {
+private:
+	LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ self;
+public:
+	CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ(const CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ&) = delete;
+	CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ(CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ)); }
+	CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ)); }
+	operator LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ() && { LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ)); return res; }
+	~CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ() { CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(self); }
+	CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ& operator=(CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ&& o) { CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ)); return *this; }
+	LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* operator ->() const { return &self; }
+};
+class CVec_TxOutZ {
+private:
+	LDKCVec_TxOutZ self;
+public:
+	CVec_TxOutZ(const CVec_TxOutZ&) = delete;
+	CVec_TxOutZ(CVec_TxOutZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TxOutZ)); }
+	CVec_TxOutZ(LDKCVec_TxOutZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TxOutZ)); }
+	operator LDKCVec_TxOutZ() && { LDKCVec_TxOutZ res = self; memset(&self, 0, sizeof(LDKCVec_TxOutZ)); return res; }
+	~CVec_TxOutZ() { CVec_TxOutZ_free(self); }
+	CVec_TxOutZ& operator=(CVec_TxOutZ&& o) { CVec_TxOutZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TxOutZ)); return *this; }
+	LDKCVec_TxOutZ* operator &() { return &self; }
+	LDKCVec_TxOutZ* operator ->() { return &self; }
+	const LDKCVec_TxOutZ* operator &() const { return &self; }
+	const LDKCVec_TxOutZ* operator ->() const { return &self; }
+};
+class CVec_UpdateFailHTLCZ {
 private:
-	LDKChainMonitor self;
+	LDKCVec_UpdateFailHTLCZ self;
 public:
-	ChainMonitor(const ChainMonitor&) = delete;
-	ChainMonitor(ChainMonitor&& o) : self(o.self) { memset(&o, 0, sizeof(ChainMonitor)); }
-	ChainMonitor(LDKChainMonitor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChainMonitor)); }
-	operator LDKChainMonitor() && { LDKChainMonitor res = self; memset(&self, 0, sizeof(LDKChainMonitor)); return res; }
-	~ChainMonitor() { ChainMonitor_free(self); }
-	ChainMonitor& operator=(ChainMonitor&& o) { ChainMonitor_free(self); self = o.self; memset(&o, 0, sizeof(ChainMonitor)); return *this; }
-	LDKChainMonitor* operator &() { return &self; }
-	LDKChainMonitor* operator ->() { return &self; }
-	const LDKChainMonitor* operator &() const { return &self; }
-	const LDKChainMonitor* operator ->() const { return &self; }
+	CVec_UpdateFailHTLCZ(const CVec_UpdateFailHTLCZ&) = delete;
+	CVec_UpdateFailHTLCZ(CVec_UpdateFailHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateFailHTLCZ)); }
+	CVec_UpdateFailHTLCZ(LDKCVec_UpdateFailHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateFailHTLCZ)); }
+	operator LDKCVec_UpdateFailHTLCZ() && { LDKCVec_UpdateFailHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateFailHTLCZ)); return res; }
+	~CVec_UpdateFailHTLCZ() { CVec_UpdateFailHTLCZ_free(self); }
+	CVec_UpdateFailHTLCZ& operator=(CVec_UpdateFailHTLCZ&& o) { CVec_UpdateFailHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateFailHTLCZ)); return *this; }
+	LDKCVec_UpdateFailHTLCZ* operator &() { return &self; }
+	LDKCVec_UpdateFailHTLCZ* operator ->() { return &self; }
+	const LDKCVec_UpdateFailHTLCZ* operator &() const { return &self; }
+	const LDKCVec_UpdateFailHTLCZ* operator ->() const { return &self; }
 };
 class CVec_SpendableOutputDescriptorZ {
 private:
@@ -3916,36 +6464,6 @@ public:
 	const LDKCVec_SpendableOutputDescriptorZ* operator &() const { return &self; }
 	const LDKCVec_SpendableOutputDescriptorZ* operator ->() const { return &self; }
 };
-class CResult_LockedChannelMonitorNoneZ {
-private:
-	LDKCResult_LockedChannelMonitorNoneZ self;
-public:
-	CResult_LockedChannelMonitorNoneZ(const CResult_LockedChannelMonitorNoneZ&) = delete;
-	CResult_LockedChannelMonitorNoneZ(CResult_LockedChannelMonitorNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_LockedChannelMonitorNoneZ)); }
-	CResult_LockedChannelMonitorNoneZ(LDKCResult_LockedChannelMonitorNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_LockedChannelMonitorNoneZ)); }
-	operator LDKCResult_LockedChannelMonitorNoneZ() && { LDKCResult_LockedChannelMonitorNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_LockedChannelMonitorNoneZ)); return res; }
-	~CResult_LockedChannelMonitorNoneZ() { CResult_LockedChannelMonitorNoneZ_free(self); }
-	CResult_LockedChannelMonitorNoneZ& operator=(CResult_LockedChannelMonitorNoneZ&& o) { CResult_LockedChannelMonitorNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_LockedChannelMonitorNoneZ)); return *this; }
-	LDKCResult_LockedChannelMonitorNoneZ* operator &() { return &self; }
-	LDKCResult_LockedChannelMonitorNoneZ* operator ->() { return &self; }
-	const LDKCResult_LockedChannelMonitorNoneZ* operator &() const { return &self; }
-	const LDKCResult_LockedChannelMonitorNoneZ* operator ->() const { return &self; }
-};
-class CResult_PhantomRouteHintsDecodeErrorZ {
-private:
-	LDKCResult_PhantomRouteHintsDecodeErrorZ self;
-public:
-	CResult_PhantomRouteHintsDecodeErrorZ(const CResult_PhantomRouteHintsDecodeErrorZ&) = delete;
-	CResult_PhantomRouteHintsDecodeErrorZ(CResult_PhantomRouteHintsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PhantomRouteHintsDecodeErrorZ)); }
-	CResult_PhantomRouteHintsDecodeErrorZ(LDKCResult_PhantomRouteHintsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ)); }
-	operator LDKCResult_PhantomRouteHintsDecodeErrorZ() && { LDKCResult_PhantomRouteHintsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ)); return res; }
-	~CResult_PhantomRouteHintsDecodeErrorZ() { CResult_PhantomRouteHintsDecodeErrorZ_free(self); }
-	CResult_PhantomRouteHintsDecodeErrorZ& operator=(CResult_PhantomRouteHintsDecodeErrorZ&& o) { CResult_PhantomRouteHintsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PhantomRouteHintsDecodeErrorZ)); return *this; }
-	LDKCResult_PhantomRouteHintsDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_PhantomRouteHintsDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_PhantomRouteHintsDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_PhantomRouteHintsDecodeErrorZ* operator ->() const { return &self; }
-};
 class COption_C2Tuple_u64u64ZZ {
 private:
 	LDKCOption_C2Tuple_u64u64ZZ self;
@@ -3961,35 +6479,20 @@ public:
 	const LDKCOption_C2Tuple_u64u64ZZ* operator &() const { return &self; }
 	const LDKCOption_C2Tuple_u64u64ZZ* operator ->() const { return &self; }
 };
-class CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ {
-private:
-	LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ self;
-public:
-	CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ(const CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ&) = delete;
-	CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ(CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ)); }
-	CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ)); }
-	operator LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ() && { LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ)); return res; }
-	~CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ() { CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_free(self); }
-	CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ& operator=(CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ&& o) { CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ)); return *this; }
-	LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* operator &() { return &self; }
-	LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* operator ->() { return &self; }
-	const LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* operator &() const { return &self; }
-	const LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* operator ->() const { return &self; }
-};
-class CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ {
+class CResult_ChannelAnnouncementDecodeErrorZ {
 private:
-	LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ self;
+	LDKCResult_ChannelAnnouncementDecodeErrorZ self;
 public:
-	CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ(const CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ&) = delete;
-	CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ(CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ)); }
-	CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ(LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ)); }
-	operator LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ() && { LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ)); return res; }
-	~CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ() { CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(self); }
-	CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ& operator=(CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ&& o) { CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ)); return *this; }
-	LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ* operator &() { return &self; }
-	LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ* operator ->() { return &self; }
-	const LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ* operator &() const { return &self; }
-	const LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ* operator ->() const { return &self; }
+	CResult_ChannelAnnouncementDecodeErrorZ(const CResult_ChannelAnnouncementDecodeErrorZ&) = delete;
+	CResult_ChannelAnnouncementDecodeErrorZ(CResult_ChannelAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelAnnouncementDecodeErrorZ)); }
+	CResult_ChannelAnnouncementDecodeErrorZ(LDKCResult_ChannelAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ)); }
+	operator LDKCResult_ChannelAnnouncementDecodeErrorZ() && { LDKCResult_ChannelAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ)); return res; }
+	~CResult_ChannelAnnouncementDecodeErrorZ() { CResult_ChannelAnnouncementDecodeErrorZ_free(self); }
+	CResult_ChannelAnnouncementDecodeErrorZ& operator=(CResult_ChannelAnnouncementDecodeErrorZ&& o) { CResult_ChannelAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelAnnouncementDecodeErrorZ)); return *this; }
+	LDKCResult_ChannelAnnouncementDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_ChannelAnnouncementDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_ChannelAnnouncementDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_ChannelAnnouncementDecodeErrorZ* operator ->() const { return &self; }
 };
 class CResult_HTLCUpdateDecodeErrorZ {
 private:
@@ -4021,66 +6524,6 @@ public:
 	const LDKC2Tuple_SignatureCVec_SignatureZZ* operator &() const { return &self; }
 	const LDKC2Tuple_SignatureCVec_SignatureZZ* operator ->() const { return &self; }
 };
-class CVec_C2Tuple_u32TxOutZZ {
-private:
-	LDKCVec_C2Tuple_u32TxOutZZ self;
-public:
-	CVec_C2Tuple_u32TxOutZZ(const CVec_C2Tuple_u32TxOutZZ&) = delete;
-	CVec_C2Tuple_u32TxOutZZ(CVec_C2Tuple_u32TxOutZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_u32TxOutZZ)); }
-	CVec_C2Tuple_u32TxOutZZ(LDKCVec_C2Tuple_u32TxOutZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_u32TxOutZZ)); }
-	operator LDKCVec_C2Tuple_u32TxOutZZ() && { LDKCVec_C2Tuple_u32TxOutZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_u32TxOutZZ)); return res; }
-	~CVec_C2Tuple_u32TxOutZZ() { CVec_C2Tuple_u32TxOutZZ_free(self); }
-	CVec_C2Tuple_u32TxOutZZ& operator=(CVec_C2Tuple_u32TxOutZZ&& o) { CVec_C2Tuple_u32TxOutZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_u32TxOutZZ)); return *this; }
-	LDKCVec_C2Tuple_u32TxOutZZ* operator &() { return &self; }
-	LDKCVec_C2Tuple_u32TxOutZZ* operator ->() { return &self; }
-	const LDKCVec_C2Tuple_u32TxOutZZ* operator &() const { return &self; }
-	const LDKCVec_C2Tuple_u32TxOutZZ* operator ->() const { return &self; }
-};
-class CResult_ChannelInfoDecodeErrorZ {
-private:
-	LDKCResult_ChannelInfoDecodeErrorZ self;
-public:
-	CResult_ChannelInfoDecodeErrorZ(const CResult_ChannelInfoDecodeErrorZ&) = delete;
-	CResult_ChannelInfoDecodeErrorZ(CResult_ChannelInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelInfoDecodeErrorZ)); }
-	CResult_ChannelInfoDecodeErrorZ(LDKCResult_ChannelInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelInfoDecodeErrorZ)); }
-	operator LDKCResult_ChannelInfoDecodeErrorZ() && { LDKCResult_ChannelInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelInfoDecodeErrorZ)); return res; }
-	~CResult_ChannelInfoDecodeErrorZ() { CResult_ChannelInfoDecodeErrorZ_free(self); }
-	CResult_ChannelInfoDecodeErrorZ& operator=(CResult_ChannelInfoDecodeErrorZ&& o) { CResult_ChannelInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelInfoDecodeErrorZ)); return *this; }
-	LDKCResult_ChannelInfoDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_ChannelInfoDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_ChannelInfoDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_ChannelInfoDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_FundingCreatedDecodeErrorZ {
-private:
-	LDKCResult_FundingCreatedDecodeErrorZ self;
-public:
-	CResult_FundingCreatedDecodeErrorZ(const CResult_FundingCreatedDecodeErrorZ&) = delete;
-	CResult_FundingCreatedDecodeErrorZ(CResult_FundingCreatedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FundingCreatedDecodeErrorZ)); }
-	CResult_FundingCreatedDecodeErrorZ(LDKCResult_FundingCreatedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FundingCreatedDecodeErrorZ)); }
-	operator LDKCResult_FundingCreatedDecodeErrorZ() && { LDKCResult_FundingCreatedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FundingCreatedDecodeErrorZ)); return res; }
-	~CResult_FundingCreatedDecodeErrorZ() { CResult_FundingCreatedDecodeErrorZ_free(self); }
-	CResult_FundingCreatedDecodeErrorZ& operator=(CResult_FundingCreatedDecodeErrorZ&& o) { CResult_FundingCreatedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FundingCreatedDecodeErrorZ)); return *this; }
-	LDKCResult_FundingCreatedDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_FundingCreatedDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_FundingCreatedDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_FundingCreatedDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_ChannelAnnouncementDecodeErrorZ {
-private:
-	LDKCResult_ChannelAnnouncementDecodeErrorZ self;
-public:
-	CResult_ChannelAnnouncementDecodeErrorZ(const CResult_ChannelAnnouncementDecodeErrorZ&) = delete;
-	CResult_ChannelAnnouncementDecodeErrorZ(CResult_ChannelAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelAnnouncementDecodeErrorZ)); }
-	CResult_ChannelAnnouncementDecodeErrorZ(LDKCResult_ChannelAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ)); }
-	operator LDKCResult_ChannelAnnouncementDecodeErrorZ() && { LDKCResult_ChannelAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ)); return res; }
-	~CResult_ChannelAnnouncementDecodeErrorZ() { CResult_ChannelAnnouncementDecodeErrorZ_free(self); }
-	CResult_ChannelAnnouncementDecodeErrorZ& operator=(CResult_ChannelAnnouncementDecodeErrorZ&& o) { CResult_ChannelAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelAnnouncementDecodeErrorZ)); return *this; }
-	LDKCResult_ChannelAnnouncementDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_ChannelAnnouncementDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_ChannelAnnouncementDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_ChannelAnnouncementDecodeErrorZ* operator ->() const { return &self; }
-};
 class CVec_OutPointZ {
 private:
 	LDKCVec_OutPointZ self;
@@ -4096,6 +6539,21 @@ public:
 	const LDKCVec_OutPointZ* operator &() const { return &self; }
 	const LDKCVec_OutPointZ* 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_PositiveTimestampCreationErrorZ {
 private:
 	LDKCResult_PositiveTimestampCreationErrorZ self;
@@ -4111,110 +6569,35 @@ public:
 	const LDKCResult_PositiveTimestampCreationErrorZ* operator &() const { return &self; }
 	const LDKCResult_PositiveTimestampCreationErrorZ* operator ->() const { return &self; }
 };
-class CResult_CVec_u8ZPeerHandleErrorZ {
-private:
-	LDKCResult_CVec_u8ZPeerHandleErrorZ self;
-public:
-	CResult_CVec_u8ZPeerHandleErrorZ(const CResult_CVec_u8ZPeerHandleErrorZ&) = delete;
-	CResult_CVec_u8ZPeerHandleErrorZ(CResult_CVec_u8ZPeerHandleErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_u8ZPeerHandleErrorZ)); }
-	CResult_CVec_u8ZPeerHandleErrorZ(LDKCResult_CVec_u8ZPeerHandleErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ)); }
-	operator LDKCResult_CVec_u8ZPeerHandleErrorZ() && { LDKCResult_CVec_u8ZPeerHandleErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ)); return res; }
-	~CResult_CVec_u8ZPeerHandleErrorZ() { CResult_CVec_u8ZPeerHandleErrorZ_free(self); }
-	CResult_CVec_u8ZPeerHandleErrorZ& operator=(CResult_CVec_u8ZPeerHandleErrorZ&& o) { CResult_CVec_u8ZPeerHandleErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_u8ZPeerHandleErrorZ)); return *this; }
-	LDKCResult_CVec_u8ZPeerHandleErrorZ* operator &() { return &self; }
-	LDKCResult_CVec_u8ZPeerHandleErrorZ* operator ->() { return &self; }
-	const LDKCResult_CVec_u8ZPeerHandleErrorZ* operator &() const { return &self; }
-	const LDKCResult_CVec_u8ZPeerHandleErrorZ* operator ->() const { return &self; }
-};
-class CResult_InvoiceFeaturesDecodeErrorZ {
-private:
-	LDKCResult_InvoiceFeaturesDecodeErrorZ self;
-public:
-	CResult_InvoiceFeaturesDecodeErrorZ(const CResult_InvoiceFeaturesDecodeErrorZ&) = delete;
-	CResult_InvoiceFeaturesDecodeErrorZ(CResult_InvoiceFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceFeaturesDecodeErrorZ)); }
-	CResult_InvoiceFeaturesDecodeErrorZ(LDKCResult_InvoiceFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ)); }
-	operator LDKCResult_InvoiceFeaturesDecodeErrorZ() && { LDKCResult_InvoiceFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ)); return res; }
-	~CResult_InvoiceFeaturesDecodeErrorZ() { CResult_InvoiceFeaturesDecodeErrorZ_free(self); }
-	CResult_InvoiceFeaturesDecodeErrorZ& operator=(CResult_InvoiceFeaturesDecodeErrorZ&& o) { CResult_InvoiceFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceFeaturesDecodeErrorZ)); return *this; }
-	LDKCResult_InvoiceFeaturesDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_InvoiceFeaturesDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_InvoiceFeaturesDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_InvoiceFeaturesDecodeErrorZ* operator ->() const { return &self; }
-};
-class COption_NetworkUpdateZ {
-private:
-	LDKCOption_NetworkUpdateZ self;
-public:
-	COption_NetworkUpdateZ(const COption_NetworkUpdateZ&) = delete;
-	COption_NetworkUpdateZ(COption_NetworkUpdateZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_NetworkUpdateZ)); }
-	COption_NetworkUpdateZ(LDKCOption_NetworkUpdateZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_NetworkUpdateZ)); }
-	operator LDKCOption_NetworkUpdateZ() && { LDKCOption_NetworkUpdateZ res = self; memset(&self, 0, sizeof(LDKCOption_NetworkUpdateZ)); return res; }
-	~COption_NetworkUpdateZ() { COption_NetworkUpdateZ_free(self); }
-	COption_NetworkUpdateZ& operator=(COption_NetworkUpdateZ&& o) { COption_NetworkUpdateZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_NetworkUpdateZ)); return *this; }
-	LDKCOption_NetworkUpdateZ* operator &() { return &self; }
-	LDKCOption_NetworkUpdateZ* operator ->() { return &self; }
-	const LDKCOption_NetworkUpdateZ* operator &() const { return &self; }
-	const LDKCOption_NetworkUpdateZ* operator ->() const { return &self; }
-};
-class COption_u64Z {
-private:
-	LDKCOption_u64Z self;
-public:
-	COption_u64Z(const COption_u64Z&) = delete;
-	COption_u64Z(COption_u64Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_u64Z)); }
-	COption_u64Z(LDKCOption_u64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_u64Z)); }
-	operator LDKCOption_u64Z() && { LDKCOption_u64Z res = self; memset(&self, 0, sizeof(LDKCOption_u64Z)); return res; }
-	~COption_u64Z() { COption_u64Z_free(self); }
-	COption_u64Z& operator=(COption_u64Z&& o) { COption_u64Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_u64Z)); return *this; }
-	LDKCOption_u64Z* operator &() { return &self; }
-	LDKCOption_u64Z* operator ->() { return &self; }
-	const LDKCOption_u64Z* operator &() const { return &self; }
-	const LDKCOption_u64Z* operator ->() const { return &self; }
-};
-class CResult_TxOutAccessErrorZ {
-private:
-	LDKCResult_TxOutAccessErrorZ self;
-public:
-	CResult_TxOutAccessErrorZ(const CResult_TxOutAccessErrorZ&) = delete;
-	CResult_TxOutAccessErrorZ(CResult_TxOutAccessErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxOutAccessErrorZ)); }
-	CResult_TxOutAccessErrorZ(LDKCResult_TxOutAccessErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxOutAccessErrorZ)); }
-	operator LDKCResult_TxOutAccessErrorZ() && { LDKCResult_TxOutAccessErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxOutAccessErrorZ)); return res; }
-	~CResult_TxOutAccessErrorZ() { CResult_TxOutAccessErrorZ_free(self); }
-	CResult_TxOutAccessErrorZ& operator=(CResult_TxOutAccessErrorZ&& o) { CResult_TxOutAccessErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxOutAccessErrorZ)); return *this; }
-	LDKCResult_TxOutAccessErrorZ* operator &() { return &self; }
-	LDKCResult_TxOutAccessErrorZ* operator ->() { return &self; }
-	const LDKCResult_TxOutAccessErrorZ* operator &() const { return &self; }
-	const LDKCResult_TxOutAccessErrorZ* operator ->() const { return &self; }
-};
-class CResult_TrustedClosingTransactionNoneZ {
-private:
-	LDKCResult_TrustedClosingTransactionNoneZ self;
-public:
-	CResult_TrustedClosingTransactionNoneZ(const CResult_TrustedClosingTransactionNoneZ&) = delete;
-	CResult_TrustedClosingTransactionNoneZ(CResult_TrustedClosingTransactionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TrustedClosingTransactionNoneZ)); }
-	CResult_TrustedClosingTransactionNoneZ(LDKCResult_TrustedClosingTransactionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TrustedClosingTransactionNoneZ)); }
-	operator LDKCResult_TrustedClosingTransactionNoneZ() && { LDKCResult_TrustedClosingTransactionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TrustedClosingTransactionNoneZ)); return res; }
-	~CResult_TrustedClosingTransactionNoneZ() { CResult_TrustedClosingTransactionNoneZ_free(self); }
-	CResult_TrustedClosingTransactionNoneZ& operator=(CResult_TrustedClosingTransactionNoneZ&& o) { CResult_TrustedClosingTransactionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TrustedClosingTransactionNoneZ)); return *this; }
-	LDKCResult_TrustedClosingTransactionNoneZ* operator &() { return &self; }
-	LDKCResult_TrustedClosingTransactionNoneZ* operator ->() { return &self; }
-	const LDKCResult_TrustedClosingTransactionNoneZ* operator &() const { return &self; }
-	const LDKCResult_TrustedClosingTransactionNoneZ* operator ->() const { return &self; }
-};
-class CResult_PaymentPreimageAPIErrorZ {
+class C2Tuple__u168_u168Z {
 private:
-	LDKCResult_PaymentPreimageAPIErrorZ self;
+	LDKC2Tuple__u168_u168Z self;
 public:
-	CResult_PaymentPreimageAPIErrorZ(const CResult_PaymentPreimageAPIErrorZ&) = delete;
-	CResult_PaymentPreimageAPIErrorZ(CResult_PaymentPreimageAPIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentPreimageAPIErrorZ)); }
-	CResult_PaymentPreimageAPIErrorZ(LDKCResult_PaymentPreimageAPIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentPreimageAPIErrorZ)); }
-	operator LDKCResult_PaymentPreimageAPIErrorZ() && { LDKCResult_PaymentPreimageAPIErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentPreimageAPIErrorZ)); return res; }
-	~CResult_PaymentPreimageAPIErrorZ() { CResult_PaymentPreimageAPIErrorZ_free(self); }
-	CResult_PaymentPreimageAPIErrorZ& operator=(CResult_PaymentPreimageAPIErrorZ&& o) { CResult_PaymentPreimageAPIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentPreimageAPIErrorZ)); return *this; }
-	LDKCResult_PaymentPreimageAPIErrorZ* operator &() { return &self; }
-	LDKCResult_PaymentPreimageAPIErrorZ* operator ->() { return &self; }
-	const LDKCResult_PaymentPreimageAPIErrorZ* operator &() const { return &self; }
-	const LDKCResult_PaymentPreimageAPIErrorZ* operator ->() const { return &self; }
+	C2Tuple__u168_u168Z(const C2Tuple__u168_u168Z&) = delete;
+	C2Tuple__u168_u168Z(C2Tuple__u168_u168Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple__u168_u168Z)); }
+	C2Tuple__u168_u168Z(LDKC2Tuple__u168_u168Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple__u168_u168Z)); }
+	operator LDKC2Tuple__u168_u168Z() && { LDKC2Tuple__u168_u168Z res = self; memset(&self, 0, sizeof(LDKC2Tuple__u168_u168Z)); return res; }
+	~C2Tuple__u168_u168Z() { C2Tuple__u168_u168Z_free(self); }
+	C2Tuple__u168_u168Z& operator=(C2Tuple__u168_u168Z&& o) { C2Tuple__u168_u168Z_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple__u168_u168Z)); return *this; }
+	LDKC2Tuple__u168_u168Z* operator &() { return &self; }
+	LDKC2Tuple__u168_u168Z* operator ->() { return &self; }
+	const LDKC2Tuple__u168_u168Z* operator &() const { return &self; }
+	const LDKC2Tuple__u168_u168Z* operator ->() const { return &self; }
+};
+class CResult_InvoiceFeaturesDecodeErrorZ {
+private:
+	LDKCResult_InvoiceFeaturesDecodeErrorZ self;
+public:
+	CResult_InvoiceFeaturesDecodeErrorZ(const CResult_InvoiceFeaturesDecodeErrorZ&) = delete;
+	CResult_InvoiceFeaturesDecodeErrorZ(CResult_InvoiceFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceFeaturesDecodeErrorZ)); }
+	CResult_InvoiceFeaturesDecodeErrorZ(LDKCResult_InvoiceFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ)); }
+	operator LDKCResult_InvoiceFeaturesDecodeErrorZ() && { LDKCResult_InvoiceFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ)); return res; }
+	~CResult_InvoiceFeaturesDecodeErrorZ() { CResult_InvoiceFeaturesDecodeErrorZ_free(self); }
+	CResult_InvoiceFeaturesDecodeErrorZ& operator=(CResult_InvoiceFeaturesDecodeErrorZ&& o) { CResult_InvoiceFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceFeaturesDecodeErrorZ)); return *this; }
+	LDKCResult_InvoiceFeaturesDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_InvoiceFeaturesDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_InvoiceFeaturesDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_InvoiceFeaturesDecodeErrorZ* operator ->() const { return &self; }
 };
 class CResult_ChannelMonitorUpdateDecodeErrorZ {
 private:
@@ -4231,35 +6614,50 @@ public:
 	const LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_RouteHintDecodeErrorZ {
+class CResult_ReplyChannelRangeDecodeErrorZ {
 private:
-	LDKCResult_RouteHintDecodeErrorZ self;
+	LDKCResult_ReplyChannelRangeDecodeErrorZ self;
 public:
-	CResult_RouteHintDecodeErrorZ(const CResult_RouteHintDecodeErrorZ&) = delete;
-	CResult_RouteHintDecodeErrorZ(CResult_RouteHintDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteHintDecodeErrorZ)); }
-	CResult_RouteHintDecodeErrorZ(LDKCResult_RouteHintDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteHintDecodeErrorZ)); }
-	operator LDKCResult_RouteHintDecodeErrorZ() && { LDKCResult_RouteHintDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteHintDecodeErrorZ)); return res; }
-	~CResult_RouteHintDecodeErrorZ() { CResult_RouteHintDecodeErrorZ_free(self); }
-	CResult_RouteHintDecodeErrorZ& operator=(CResult_RouteHintDecodeErrorZ&& o) { CResult_RouteHintDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteHintDecodeErrorZ)); return *this; }
-	LDKCResult_RouteHintDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_RouteHintDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_RouteHintDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_RouteHintDecodeErrorZ* 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 C2Tuple_PublicKeyTypeZ {
+class CResult_InvoiceSignOrCreationErrorZ {
 private:
-	LDKC2Tuple_PublicKeyTypeZ self;
+	LDKCResult_InvoiceSignOrCreationErrorZ self;
 public:
-	C2Tuple_PublicKeyTypeZ(const C2Tuple_PublicKeyTypeZ&) = delete;
-	C2Tuple_PublicKeyTypeZ(C2Tuple_PublicKeyTypeZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_PublicKeyTypeZ)); }
-	C2Tuple_PublicKeyTypeZ(LDKC2Tuple_PublicKeyTypeZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_PublicKeyTypeZ)); }
-	operator LDKC2Tuple_PublicKeyTypeZ() && { LDKC2Tuple_PublicKeyTypeZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_PublicKeyTypeZ)); return res; }
-	~C2Tuple_PublicKeyTypeZ() { C2Tuple_PublicKeyTypeZ_free(self); }
-	C2Tuple_PublicKeyTypeZ& operator=(C2Tuple_PublicKeyTypeZ&& o) { C2Tuple_PublicKeyTypeZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_PublicKeyTypeZ)); return *this; }
-	LDKC2Tuple_PublicKeyTypeZ* operator &() { return &self; }
-	LDKC2Tuple_PublicKeyTypeZ* operator ->() { return &self; }
-	const LDKC2Tuple_PublicKeyTypeZ* operator &() const { return &self; }
-	const LDKC2Tuple_PublicKeyTypeZ* operator ->() const { return &self; }
+	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 CResult_TrustedClosingTransactionNoneZ {
+private:
+	LDKCResult_TrustedClosingTransactionNoneZ self;
+public:
+	CResult_TrustedClosingTransactionNoneZ(const CResult_TrustedClosingTransactionNoneZ&) = delete;
+	CResult_TrustedClosingTransactionNoneZ(CResult_TrustedClosingTransactionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TrustedClosingTransactionNoneZ)); }
+	CResult_TrustedClosingTransactionNoneZ(LDKCResult_TrustedClosingTransactionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TrustedClosingTransactionNoneZ)); }
+	operator LDKCResult_TrustedClosingTransactionNoneZ() && { LDKCResult_TrustedClosingTransactionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TrustedClosingTransactionNoneZ)); return res; }
+	~CResult_TrustedClosingTransactionNoneZ() { CResult_TrustedClosingTransactionNoneZ_free(self); }
+	CResult_TrustedClosingTransactionNoneZ& operator=(CResult_TrustedClosingTransactionNoneZ&& o) { CResult_TrustedClosingTransactionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TrustedClosingTransactionNoneZ)); return *this; }
+	LDKCResult_TrustedClosingTransactionNoneZ* operator &() { return &self; }
+	LDKCResult_TrustedClosingTransactionNoneZ* operator ->() { return &self; }
+	const LDKCResult_TrustedClosingTransactionNoneZ* operator &() const { return &self; }
+	const LDKCResult_TrustedClosingTransactionNoneZ* operator ->() const { return &self; }
 };
 class CResult_NetAddressDecodeErrorZ {
 private:
@@ -4276,6 +6674,21 @@ public:
 	const LDKCResult_NetAddressDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_NetAddressDecodeErrorZ* operator ->() const { return &self; }
 };
+class C2Tuple_PublicKeyTypeZ {
+private:
+	LDKC2Tuple_PublicKeyTypeZ self;
+public:
+	C2Tuple_PublicKeyTypeZ(const C2Tuple_PublicKeyTypeZ&) = delete;
+	C2Tuple_PublicKeyTypeZ(C2Tuple_PublicKeyTypeZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_PublicKeyTypeZ)); }
+	C2Tuple_PublicKeyTypeZ(LDKC2Tuple_PublicKeyTypeZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_PublicKeyTypeZ)); }
+	operator LDKC2Tuple_PublicKeyTypeZ() && { LDKC2Tuple_PublicKeyTypeZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_PublicKeyTypeZ)); return res; }
+	~C2Tuple_PublicKeyTypeZ() { C2Tuple_PublicKeyTypeZ_free(self); }
+	C2Tuple_PublicKeyTypeZ& operator=(C2Tuple_PublicKeyTypeZ&& o) { C2Tuple_PublicKeyTypeZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_PublicKeyTypeZ)); return *this; }
+	LDKC2Tuple_PublicKeyTypeZ* operator &() { return &self; }
+	LDKC2Tuple_PublicKeyTypeZ* operator ->() { return &self; }
+	const LDKC2Tuple_PublicKeyTypeZ* operator &() const { return &self; }
+	const LDKC2Tuple_PublicKeyTypeZ* operator ->() const { return &self; }
+};
 class CResult_ChannelReestablishDecodeErrorZ {
 private:
 	LDKCResult_ChannelReestablishDecodeErrorZ self;
@@ -4291,35 +6704,20 @@ 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 {
+class CResult_OnionMessageDecodeErrorZ {
 private:
-	LDKCVec_UpdateAddHTLCZ self;
+	LDKCResult_OnionMessageDecodeErrorZ self;
 public:
-	CVec_UpdateAddHTLCZ(const CVec_UpdateAddHTLCZ&) = delete;
-	CVec_UpdateAddHTLCZ(CVec_UpdateAddHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateAddHTLCZ)); }
-	CVec_UpdateAddHTLCZ(LDKCVec_UpdateAddHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateAddHTLCZ)); }
-	operator LDKCVec_UpdateAddHTLCZ() && { LDKCVec_UpdateAddHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateAddHTLCZ)); return res; }
-	~CVec_UpdateAddHTLCZ() { CVec_UpdateAddHTLCZ_free(self); }
-	CVec_UpdateAddHTLCZ& operator=(CVec_UpdateAddHTLCZ&& o) { CVec_UpdateAddHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateAddHTLCZ)); return *this; }
-	LDKCVec_UpdateAddHTLCZ* operator &() { return &self; }
-	LDKCVec_UpdateAddHTLCZ* operator ->() { return &self; }
-	const LDKCVec_UpdateAddHTLCZ* operator &() const { return &self; }
-	const LDKCVec_UpdateAddHTLCZ* operator ->() const { return &self; }
+	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_UnsignedNodeAnnouncementDecodeErrorZ {
 private:
@@ -4336,21 +6734,6 @@ public:
 	const LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator ->() const { return &self; }
 };
-class COption_u32Z {
-private:
-	LDKCOption_u32Z self;
-public:
-	COption_u32Z(const COption_u32Z&) = delete;
-	COption_u32Z(COption_u32Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_u32Z)); }
-	COption_u32Z(LDKCOption_u32Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_u32Z)); }
-	operator LDKCOption_u32Z() && { LDKCOption_u32Z res = self; memset(&self, 0, sizeof(LDKCOption_u32Z)); return res; }
-	~COption_u32Z() { COption_u32Z_free(self); }
-	COption_u32Z& operator=(COption_u32Z&& o) { COption_u32Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_u32Z)); return *this; }
-	LDKCOption_u32Z* operator &() { return &self; }
-	LDKCOption_u32Z* operator ->() { return &self; }
-	const LDKCOption_u32Z* operator &() const { return &self; }
-	const LDKCOption_u32Z* operator ->() const { return &self; }
-};
 class CResult_InitFeaturesDecodeErrorZ {
 private:
 	LDKCResult_InitFeaturesDecodeErrorZ self;
@@ -4366,170 +6749,50 @@ public:
 	const LDKCResult_InitFeaturesDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_InitFeaturesDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_StaticPaymentOutputDescriptorDecodeErrorZ {
-private:
-	LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ self;
-public:
-	CResult_StaticPaymentOutputDescriptorDecodeErrorZ(const CResult_StaticPaymentOutputDescriptorDecodeErrorZ&) = delete;
-	CResult_StaticPaymentOutputDescriptorDecodeErrorZ(CResult_StaticPaymentOutputDescriptorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_StaticPaymentOutputDescriptorDecodeErrorZ)); }
-	CResult_StaticPaymentOutputDescriptorDecodeErrorZ(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ)); }
-	operator LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ() && { LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ)); return res; }
-	~CResult_StaticPaymentOutputDescriptorDecodeErrorZ() { CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(self); }
-	CResult_StaticPaymentOutputDescriptorDecodeErrorZ& operator=(CResult_StaticPaymentOutputDescriptorDecodeErrorZ&& o) { CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_StaticPaymentOutputDescriptorDecodeErrorZ)); return *this; }
-	LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_PaymentIdPaymentSendFailureZ {
-private:
-	LDKCResult_PaymentIdPaymentSendFailureZ self;
-public:
-	CResult_PaymentIdPaymentSendFailureZ(const CResult_PaymentIdPaymentSendFailureZ&) = delete;
-	CResult_PaymentIdPaymentSendFailureZ(CResult_PaymentIdPaymentSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentIdPaymentSendFailureZ)); }
-	CResult_PaymentIdPaymentSendFailureZ(LDKCResult_PaymentIdPaymentSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentIdPaymentSendFailureZ)); }
-	operator LDKCResult_PaymentIdPaymentSendFailureZ() && { LDKCResult_PaymentIdPaymentSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentIdPaymentSendFailureZ)); return res; }
-	~CResult_PaymentIdPaymentSendFailureZ() { CResult_PaymentIdPaymentSendFailureZ_free(self); }
-	CResult_PaymentIdPaymentSendFailureZ& operator=(CResult_PaymentIdPaymentSendFailureZ&& o) { CResult_PaymentIdPaymentSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentIdPaymentSendFailureZ)); return *this; }
-	LDKCResult_PaymentIdPaymentSendFailureZ* operator &() { return &self; }
-	LDKCResult_PaymentIdPaymentSendFailureZ* operator ->() { return &self; }
-	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;
-public:
-	CResult_CommitmentTransactionDecodeErrorZ(const CResult_CommitmentTransactionDecodeErrorZ&) = delete;
-	CResult_CommitmentTransactionDecodeErrorZ(CResult_CommitmentTransactionDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CommitmentTransactionDecodeErrorZ)); }
-	CResult_CommitmentTransactionDecodeErrorZ(LDKCResult_CommitmentTransactionDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ)); }
-	operator LDKCResult_CommitmentTransactionDecodeErrorZ() && { LDKCResult_CommitmentTransactionDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ)); return res; }
-	~CResult_CommitmentTransactionDecodeErrorZ() { CResult_CommitmentTransactionDecodeErrorZ_free(self); }
-	CResult_CommitmentTransactionDecodeErrorZ& operator=(CResult_CommitmentTransactionDecodeErrorZ&& o) { CResult_CommitmentTransactionDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CommitmentTransactionDecodeErrorZ)); return *this; }
-	LDKCResult_CommitmentTransactionDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_CommitmentTransactionDecodeErrorZ* operator ->() { return &self; }
-	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;
-public:
-	CResult_TransactionNoneZ(const CResult_TransactionNoneZ&) = delete;
-	CResult_TransactionNoneZ(CResult_TransactionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TransactionNoneZ)); }
-	CResult_TransactionNoneZ(LDKCResult_TransactionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TransactionNoneZ)); }
-	operator LDKCResult_TransactionNoneZ() && { LDKCResult_TransactionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TransactionNoneZ)); return res; }
-	~CResult_TransactionNoneZ() { CResult_TransactionNoneZ_free(self); }
-	CResult_TransactionNoneZ& operator=(CResult_TransactionNoneZ&& o) { CResult_TransactionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TransactionNoneZ)); return *this; }
-	LDKCResult_TransactionNoneZ* operator &() { return &self; }
-	LDKCResult_TransactionNoneZ* operator ->() { return &self; }
-	const LDKCResult_TransactionNoneZ* operator &() const { return &self; }
-	const LDKCResult_TransactionNoneZ* operator ->() const { return &self; }
-};
-class CResult_ClosingSignedFeeRangeDecodeErrorZ {
+class CResult_PublicKeyNoneZ {
 private:
-	LDKCResult_ClosingSignedFeeRangeDecodeErrorZ self;
+	LDKCResult_PublicKeyNoneZ self;
 public:
-	CResult_ClosingSignedFeeRangeDecodeErrorZ(const CResult_ClosingSignedFeeRangeDecodeErrorZ&) = delete;
-	CResult_ClosingSignedFeeRangeDecodeErrorZ(CResult_ClosingSignedFeeRangeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ClosingSignedFeeRangeDecodeErrorZ)); }
-	CResult_ClosingSignedFeeRangeDecodeErrorZ(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ)); }
-	operator LDKCResult_ClosingSignedFeeRangeDecodeErrorZ() && { LDKCResult_ClosingSignedFeeRangeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ)); return res; }
-	~CResult_ClosingSignedFeeRangeDecodeErrorZ() { CResult_ClosingSignedFeeRangeDecodeErrorZ_free(self); }
-	CResult_ClosingSignedFeeRangeDecodeErrorZ& operator=(CResult_ClosingSignedFeeRangeDecodeErrorZ&& o) { CResult_ClosingSignedFeeRangeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ClosingSignedFeeRangeDecodeErrorZ)); return *this; }
-	LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator ->() const { return &self; }
+	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_PingDecodeErrorZ {
-private:
-	LDKCResult_PingDecodeErrorZ self;
-public:
-	CResult_PingDecodeErrorZ(const CResult_PingDecodeErrorZ&) = delete;
-	CResult_PingDecodeErrorZ(CResult_PingDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PingDecodeErrorZ)); }
-	CResult_PingDecodeErrorZ(LDKCResult_PingDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PingDecodeErrorZ)); }
-	operator LDKCResult_PingDecodeErrorZ() && { LDKCResult_PingDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PingDecodeErrorZ)); return res; }
-	~CResult_PingDecodeErrorZ() { CResult_PingDecodeErrorZ_free(self); }
-	CResult_PingDecodeErrorZ& operator=(CResult_PingDecodeErrorZ&& o) { CResult_PingDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PingDecodeErrorZ)); return *this; }
-	LDKCResult_PingDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_PingDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_PingDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_PingDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_GossipTimestampFilterDecodeErrorZ {
-private:
-	LDKCResult_GossipTimestampFilterDecodeErrorZ 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;
-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; }
+private:
+	LDKCResult_PingDecodeErrorZ self;
+public:
+	CResult_PingDecodeErrorZ(const CResult_PingDecodeErrorZ&) = delete;
+	CResult_PingDecodeErrorZ(CResult_PingDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PingDecodeErrorZ)); }
+	CResult_PingDecodeErrorZ(LDKCResult_PingDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PingDecodeErrorZ)); }
+	operator LDKCResult_PingDecodeErrorZ() && { LDKCResult_PingDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PingDecodeErrorZ)); return res; }
+	~CResult_PingDecodeErrorZ() { CResult_PingDecodeErrorZ_free(self); }
+	CResult_PingDecodeErrorZ& operator=(CResult_PingDecodeErrorZ&& o) { CResult_PingDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PingDecodeErrorZ)); return *this; }
+	LDKCResult_PingDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_PingDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_PingDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_PingDecodeErrorZ* operator ->() const { return &self; }
 };
-class COption_FilterZ {
+class CResult_BlindedHopFeaturesDecodeErrorZ {
 private:
-	LDKCOption_FilterZ self;
+	LDKCResult_BlindedHopFeaturesDecodeErrorZ 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_BlindedHopFeaturesDecodeErrorZ(const CResult_BlindedHopFeaturesDecodeErrorZ&) = delete;
+	CResult_BlindedHopFeaturesDecodeErrorZ(CResult_BlindedHopFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedHopFeaturesDecodeErrorZ)); }
+	CResult_BlindedHopFeaturesDecodeErrorZ(LDKCResult_BlindedHopFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedHopFeaturesDecodeErrorZ)); }
+	operator LDKCResult_BlindedHopFeaturesDecodeErrorZ() && { LDKCResult_BlindedHopFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedHopFeaturesDecodeErrorZ)); return res; }
+	~CResult_BlindedHopFeaturesDecodeErrorZ() { CResult_BlindedHopFeaturesDecodeErrorZ_free(self); }
+	CResult_BlindedHopFeaturesDecodeErrorZ& operator=(CResult_BlindedHopFeaturesDecodeErrorZ&& o) { CResult_BlindedHopFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedHopFeaturesDecodeErrorZ)); return *this; }
+	LDKCResult_BlindedHopFeaturesDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_BlindedHopFeaturesDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_BlindedHopFeaturesDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_BlindedHopFeaturesDecodeErrorZ* operator ->() const { return &self; }
 };
 class CVec_TransactionOutputsZ {
 private:
@@ -4546,35 +6809,20 @@ public:
 	const LDKCVec_TransactionOutputsZ* operator &() const { return &self; }
 	const LDKCVec_TransactionOutputsZ* operator ->() const { return &self; }
 };
-class CResult_ErrorMessageDecodeErrorZ {
-private:
-	LDKCResult_ErrorMessageDecodeErrorZ self;
-public:
-	CResult_ErrorMessageDecodeErrorZ(const CResult_ErrorMessageDecodeErrorZ&) = delete;
-	CResult_ErrorMessageDecodeErrorZ(CResult_ErrorMessageDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ErrorMessageDecodeErrorZ)); }
-	CResult_ErrorMessageDecodeErrorZ(LDKCResult_ErrorMessageDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ErrorMessageDecodeErrorZ)); }
-	operator LDKCResult_ErrorMessageDecodeErrorZ() && { LDKCResult_ErrorMessageDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ErrorMessageDecodeErrorZ)); return res; }
-	~CResult_ErrorMessageDecodeErrorZ() { CResult_ErrorMessageDecodeErrorZ_free(self); }
-	CResult_ErrorMessageDecodeErrorZ& operator=(CResult_ErrorMessageDecodeErrorZ&& o) { CResult_ErrorMessageDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ErrorMessageDecodeErrorZ)); return *this; }
-	LDKCResult_ErrorMessageDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_ErrorMessageDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_ErrorMessageDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_ErrorMessageDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_OpenChannelDecodeErrorZ {
+class COption_HTLCClaimZ {
 private:
-	LDKCResult_OpenChannelDecodeErrorZ self;
+	LDKCOption_HTLCClaimZ self;
 public:
-	CResult_OpenChannelDecodeErrorZ(const CResult_OpenChannelDecodeErrorZ&) = delete;
-	CResult_OpenChannelDecodeErrorZ(CResult_OpenChannelDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OpenChannelDecodeErrorZ)); }
-	CResult_OpenChannelDecodeErrorZ(LDKCResult_OpenChannelDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OpenChannelDecodeErrorZ)); }
-	operator LDKCResult_OpenChannelDecodeErrorZ() && { LDKCResult_OpenChannelDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OpenChannelDecodeErrorZ)); return res; }
-	~CResult_OpenChannelDecodeErrorZ() { CResult_OpenChannelDecodeErrorZ_free(self); }
-	CResult_OpenChannelDecodeErrorZ& operator=(CResult_OpenChannelDecodeErrorZ&& o) { CResult_OpenChannelDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OpenChannelDecodeErrorZ)); return *this; }
-	LDKCResult_OpenChannelDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_OpenChannelDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_OpenChannelDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_OpenChannelDecodeErrorZ* operator ->() const { return &self; }
+	COption_HTLCClaimZ(const COption_HTLCClaimZ&) = delete;
+	COption_HTLCClaimZ(COption_HTLCClaimZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_HTLCClaimZ)); }
+	COption_HTLCClaimZ(LDKCOption_HTLCClaimZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_HTLCClaimZ)); }
+	operator LDKCOption_HTLCClaimZ() && { LDKCOption_HTLCClaimZ res = self; memset(&self, 0, sizeof(LDKCOption_HTLCClaimZ)); return res; }
+	~COption_HTLCClaimZ() { COption_HTLCClaimZ_free(self); }
+	COption_HTLCClaimZ& operator=(COption_HTLCClaimZ&& o) { COption_HTLCClaimZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_HTLCClaimZ)); return *this; }
+	LDKCOption_HTLCClaimZ* operator &() { return &self; }
+	LDKCOption_HTLCClaimZ* operator ->() { return &self; }
+	const LDKCOption_HTLCClaimZ* operator &() const { return &self; }
+	const LDKCOption_HTLCClaimZ* operator ->() const { return &self; }
 };
 class CVec_CVec_u8ZZ {
 private:
@@ -4591,20 +6839,20 @@ public:
 	const LDKCVec_CVec_u8ZZ* operator &() const { return &self; }
 	const LDKCVec_CVec_u8ZZ* operator ->() const { return &self; }
 };
-class CResult_SecretKeyErrorZ {
+class CResult_COption_CustomOnionMessageContentsZDecodeErrorZ {
 private:
-	LDKCResult_SecretKeyErrorZ self;
+	LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ self;
 public:
-	CResult_SecretKeyErrorZ(const CResult_SecretKeyErrorZ&) = delete;
-	CResult_SecretKeyErrorZ(CResult_SecretKeyErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SecretKeyErrorZ)); }
-	CResult_SecretKeyErrorZ(LDKCResult_SecretKeyErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SecretKeyErrorZ)); }
-	operator LDKCResult_SecretKeyErrorZ() && { LDKCResult_SecretKeyErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SecretKeyErrorZ)); return res; }
-	~CResult_SecretKeyErrorZ() { CResult_SecretKeyErrorZ_free(self); }
-	CResult_SecretKeyErrorZ& operator=(CResult_SecretKeyErrorZ&& o) { CResult_SecretKeyErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SecretKeyErrorZ)); return *this; }
-	LDKCResult_SecretKeyErrorZ* operator &() { return &self; }
-	LDKCResult_SecretKeyErrorZ* operator ->() { return &self; }
-	const LDKCResult_SecretKeyErrorZ* operator &() const { return &self; }
-	const LDKCResult_SecretKeyErrorZ* operator ->() const { return &self; }
+	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_ShutdownScriptDecodeErrorZ {
 private:
@@ -4636,21 +6884,6 @@ public:
 	const LDKCResult_ProbabilisticScorerDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_ProbabilisticScorerDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_QueryChannelRangeDecodeErrorZ {
-private:
-	LDKCResult_QueryChannelRangeDecodeErrorZ self;
-public:
-	CResult_QueryChannelRangeDecodeErrorZ(const CResult_QueryChannelRangeDecodeErrorZ&) = delete;
-	CResult_QueryChannelRangeDecodeErrorZ(CResult_QueryChannelRangeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_QueryChannelRangeDecodeErrorZ)); }
-	CResult_QueryChannelRangeDecodeErrorZ(LDKCResult_QueryChannelRangeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ)); }
-	operator LDKCResult_QueryChannelRangeDecodeErrorZ() && { LDKCResult_QueryChannelRangeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ)); return res; }
-	~CResult_QueryChannelRangeDecodeErrorZ() { CResult_QueryChannelRangeDecodeErrorZ_free(self); }
-	CResult_QueryChannelRangeDecodeErrorZ& operator=(CResult_QueryChannelRangeDecodeErrorZ&& o) { CResult_QueryChannelRangeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_QueryChannelRangeDecodeErrorZ)); return *this; }
-	LDKCResult_QueryChannelRangeDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_QueryChannelRangeDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_QueryChannelRangeDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_QueryChannelRangeDecodeErrorZ* operator ->() const { return &self; }
-};
 class CResult_TxCreationKeysDecodeErrorZ {
 private:
 	LDKCResult_TxCreationKeysDecodeErrorZ self;
@@ -4681,96 +6914,6 @@ public:
 	const LDKC2Tuple_usizeTransactionZ* operator &() const { return &self; }
 	const LDKC2Tuple_usizeTransactionZ* operator ->() const { return &self; }
 };
-class CResult_ChannelFeaturesDecodeErrorZ {
-private:
-	LDKCResult_ChannelFeaturesDecodeErrorZ self;
-public:
-	CResult_ChannelFeaturesDecodeErrorZ(const CResult_ChannelFeaturesDecodeErrorZ&) = delete;
-	CResult_ChannelFeaturesDecodeErrorZ(CResult_ChannelFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelFeaturesDecodeErrorZ)); }
-	CResult_ChannelFeaturesDecodeErrorZ(LDKCResult_ChannelFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ)); }
-	operator LDKCResult_ChannelFeaturesDecodeErrorZ() && { LDKCResult_ChannelFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ)); return res; }
-	~CResult_ChannelFeaturesDecodeErrorZ() { CResult_ChannelFeaturesDecodeErrorZ_free(self); }
-	CResult_ChannelFeaturesDecodeErrorZ& operator=(CResult_ChannelFeaturesDecodeErrorZ&& o) { CResult_ChannelFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelFeaturesDecodeErrorZ)); return *this; }
-	LDKCResult_ChannelFeaturesDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_ChannelFeaturesDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_ChannelFeaturesDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_ChannelFeaturesDecodeErrorZ* operator ->() const { return &self; }
-};
-class CVec_ChannelMonitorZ {
-private:
-	LDKCVec_ChannelMonitorZ self;
-public:
-	CVec_ChannelMonitorZ(const CVec_ChannelMonitorZ&) = delete;
-	CVec_ChannelMonitorZ(CVec_ChannelMonitorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ChannelMonitorZ)); }
-	CVec_ChannelMonitorZ(LDKCVec_ChannelMonitorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ChannelMonitorZ)); }
-	operator LDKCVec_ChannelMonitorZ() && { LDKCVec_ChannelMonitorZ res = self; memset(&self, 0, sizeof(LDKCVec_ChannelMonitorZ)); return res; }
-	~CVec_ChannelMonitorZ() { CVec_ChannelMonitorZ_free(self); }
-	CVec_ChannelMonitorZ& operator=(CVec_ChannelMonitorZ&& o) { CVec_ChannelMonitorZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ChannelMonitorZ)); return *this; }
-	LDKCVec_ChannelMonitorZ* operator &() { return &self; }
-	LDKCVec_ChannelMonitorZ* operator ->() { return &self; }
-	const LDKCVec_ChannelMonitorZ* operator &() const { return &self; }
-	const LDKCVec_ChannelMonitorZ* operator ->() const { return &self; }
-};
-class CVec_TransactionZ {
-private:
-	LDKCVec_TransactionZ self;
-public:
-	CVec_TransactionZ(const CVec_TransactionZ&) = delete;
-	CVec_TransactionZ(CVec_TransactionZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TransactionZ)); }
-	CVec_TransactionZ(LDKCVec_TransactionZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TransactionZ)); }
-	operator LDKCVec_TransactionZ() && { LDKCVec_TransactionZ res = self; memset(&self, 0, sizeof(LDKCVec_TransactionZ)); return res; }
-	~CVec_TransactionZ() { CVec_TransactionZ_free(self); }
-	CVec_TransactionZ& operator=(CVec_TransactionZ&& o) { CVec_TransactionZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TransactionZ)); return *this; }
-	LDKCVec_TransactionZ* operator &() { return &self; }
-	LDKCVec_TransactionZ* operator ->() { return &self; }
-	const LDKCVec_TransactionZ* operator &() const { return &self; }
-	const LDKCVec_TransactionZ* operator ->() const { return &self; }
-};
-class CResult_ChannelReadyDecodeErrorZ {
-private:
-	LDKCResult_ChannelReadyDecodeErrorZ self;
-public:
-	CResult_ChannelReadyDecodeErrorZ(const CResult_ChannelReadyDecodeErrorZ&) = delete;
-	CResult_ChannelReadyDecodeErrorZ(CResult_ChannelReadyDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelReadyDecodeErrorZ)); }
-	CResult_ChannelReadyDecodeErrorZ(LDKCResult_ChannelReadyDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelReadyDecodeErrorZ)); }
-	operator LDKCResult_ChannelReadyDecodeErrorZ() && { LDKCResult_ChannelReadyDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelReadyDecodeErrorZ)); return res; }
-	~CResult_ChannelReadyDecodeErrorZ() { CResult_ChannelReadyDecodeErrorZ_free(self); }
-	CResult_ChannelReadyDecodeErrorZ& operator=(CResult_ChannelReadyDecodeErrorZ&& o) { CResult_ChannelReadyDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelReadyDecodeErrorZ)); return *this; }
-	LDKCResult_ChannelReadyDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_ChannelReadyDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_ChannelReadyDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_ChannelReadyDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_RouteHopDecodeErrorZ {
-private:
-	LDKCResult_RouteHopDecodeErrorZ self;
-public:
-	CResult_RouteHopDecodeErrorZ(const CResult_RouteHopDecodeErrorZ&) = delete;
-	CResult_RouteHopDecodeErrorZ(CResult_RouteHopDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteHopDecodeErrorZ)); }
-	CResult_RouteHopDecodeErrorZ(LDKCResult_RouteHopDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteHopDecodeErrorZ)); }
-	operator LDKCResult_RouteHopDecodeErrorZ() && { LDKCResult_RouteHopDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteHopDecodeErrorZ)); return res; }
-	~CResult_RouteHopDecodeErrorZ() { CResult_RouteHopDecodeErrorZ_free(self); }
-	CResult_RouteHopDecodeErrorZ& operator=(CResult_RouteHopDecodeErrorZ&& o) { CResult_RouteHopDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteHopDecodeErrorZ)); return *this; }
-	LDKCResult_RouteHopDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_RouteHopDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_RouteHopDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_RouteHopDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_UpdateFeeDecodeErrorZ {
-private:
-	LDKCResult_UpdateFeeDecodeErrorZ self;
-public:
-	CResult_UpdateFeeDecodeErrorZ(const CResult_UpdateFeeDecodeErrorZ&) = delete;
-	CResult_UpdateFeeDecodeErrorZ(CResult_UpdateFeeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateFeeDecodeErrorZ)); }
-	CResult_UpdateFeeDecodeErrorZ(LDKCResult_UpdateFeeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateFeeDecodeErrorZ)); }
-	operator LDKCResult_UpdateFeeDecodeErrorZ() && { LDKCResult_UpdateFeeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateFeeDecodeErrorZ)); return res; }
-	~CResult_UpdateFeeDecodeErrorZ() { CResult_UpdateFeeDecodeErrorZ_free(self); }
-	CResult_UpdateFeeDecodeErrorZ& operator=(CResult_UpdateFeeDecodeErrorZ&& o) { CResult_UpdateFeeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateFeeDecodeErrorZ)); return *this; }
-	LDKCResult_UpdateFeeDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_UpdateFeeDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_UpdateFeeDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_UpdateFeeDecodeErrorZ* operator ->() const { return &self; }
-};
 class CResult_NodeAnnouncementDecodeErrorZ {
 private:
 	LDKCResult_NodeAnnouncementDecodeErrorZ self;
@@ -4786,140 +6929,80 @@ public:
 	const LDKCResult_NodeAnnouncementDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_NodeAnnouncementDecodeErrorZ* operator ->() const { return &self; }
 };
-class CVec_BalanceZ {
-private:
-	LDKCVec_BalanceZ self;
-public:
-	CVec_BalanceZ(const CVec_BalanceZ&) = delete;
-	CVec_BalanceZ(CVec_BalanceZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_BalanceZ)); }
-	CVec_BalanceZ(LDKCVec_BalanceZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_BalanceZ)); }
-	operator LDKCVec_BalanceZ() && { LDKCVec_BalanceZ res = self; memset(&self, 0, sizeof(LDKCVec_BalanceZ)); return res; }
-	~CVec_BalanceZ() { CVec_BalanceZ_free(self); }
-	CVec_BalanceZ& operator=(CVec_BalanceZ&& o) { CVec_BalanceZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_BalanceZ)); return *this; }
-	LDKCVec_BalanceZ* operator &() { return &self; }
-	LDKCVec_BalanceZ* operator ->() { return &self; }
-	const LDKCVec_BalanceZ* operator &() const { return &self; }
-	const LDKCVec_BalanceZ* operator ->() const { return &self; }
-};
-class CResult_HTLCOutputInCommitmentDecodeErrorZ {
-private:
-	LDKCResult_HTLCOutputInCommitmentDecodeErrorZ self;
-public:
-	CResult_HTLCOutputInCommitmentDecodeErrorZ(const CResult_HTLCOutputInCommitmentDecodeErrorZ&) = delete;
-	CResult_HTLCOutputInCommitmentDecodeErrorZ(CResult_HTLCOutputInCommitmentDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HTLCOutputInCommitmentDecodeErrorZ)); }
-	CResult_HTLCOutputInCommitmentDecodeErrorZ(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ)); }
-	operator LDKCResult_HTLCOutputInCommitmentDecodeErrorZ() && { LDKCResult_HTLCOutputInCommitmentDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ)); return res; }
-	~CResult_HTLCOutputInCommitmentDecodeErrorZ() { CResult_HTLCOutputInCommitmentDecodeErrorZ_free(self); }
-	CResult_HTLCOutputInCommitmentDecodeErrorZ& operator=(CResult_HTLCOutputInCommitmentDecodeErrorZ&& o) { CResult_HTLCOutputInCommitmentDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HTLCOutputInCommitmentDecodeErrorZ)); return *this; }
-	LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_boolLightningErrorZ {
-private:
-	LDKCResult_boolLightningErrorZ self;
-public:
-	CResult_boolLightningErrorZ(const CResult_boolLightningErrorZ&) = delete;
-	CResult_boolLightningErrorZ(CResult_boolLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_boolLightningErrorZ)); }
-	CResult_boolLightningErrorZ(LDKCResult_boolLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_boolLightningErrorZ)); }
-	operator LDKCResult_boolLightningErrorZ() && { LDKCResult_boolLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_boolLightningErrorZ)); return res; }
-	~CResult_boolLightningErrorZ() { CResult_boolLightningErrorZ_free(self); }
-	CResult_boolLightningErrorZ& operator=(CResult_boolLightningErrorZ&& o) { CResult_boolLightningErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_boolLightningErrorZ)); return *this; }
-	LDKCResult_boolLightningErrorZ* operator &() { return &self; }
-	LDKCResult_boolLightningErrorZ* operator ->() { return &self; }
-	const LDKCResult_boolLightningErrorZ* operator &() const { return &self; }
-	const LDKCResult_boolLightningErrorZ* operator ->() const { return &self; }
-};
-class CResult_TxCreationKeysErrorZ {
-private:
-	LDKCResult_TxCreationKeysErrorZ self;
-public:
-	CResult_TxCreationKeysErrorZ(const CResult_TxCreationKeysErrorZ&) = delete;
-	CResult_TxCreationKeysErrorZ(CResult_TxCreationKeysErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxCreationKeysErrorZ)); }
-	CResult_TxCreationKeysErrorZ(LDKCResult_TxCreationKeysErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxCreationKeysErrorZ)); }
-	operator LDKCResult_TxCreationKeysErrorZ() && { LDKCResult_TxCreationKeysErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxCreationKeysErrorZ)); return res; }
-	~CResult_TxCreationKeysErrorZ() { CResult_TxCreationKeysErrorZ_free(self); }
-	CResult_TxCreationKeysErrorZ& operator=(CResult_TxCreationKeysErrorZ&& o) { CResult_TxCreationKeysErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxCreationKeysErrorZ)); return *this; }
-	LDKCResult_TxCreationKeysErrorZ* operator &() { return &self; }
-	LDKCResult_TxCreationKeysErrorZ* operator ->() { return &self; }
-	const LDKCResult_TxCreationKeysErrorZ* operator &() const { return &self; }
-	const LDKCResult_TxCreationKeysErrorZ* operator ->() const { return &self; }
-};
-class CResult_NodeIdDecodeErrorZ {
+class CResult_BlindedPathDecodeErrorZ {
 private:
-	LDKCResult_NodeIdDecodeErrorZ self;
+	LDKCResult_BlindedPathDecodeErrorZ self;
 public:
-	CResult_NodeIdDecodeErrorZ(const CResult_NodeIdDecodeErrorZ&) = delete;
-	CResult_NodeIdDecodeErrorZ(CResult_NodeIdDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeIdDecodeErrorZ)); }
-	CResult_NodeIdDecodeErrorZ(LDKCResult_NodeIdDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeIdDecodeErrorZ)); }
-	operator LDKCResult_NodeIdDecodeErrorZ() && { LDKCResult_NodeIdDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeIdDecodeErrorZ)); return res; }
-	~CResult_NodeIdDecodeErrorZ() { CResult_NodeIdDecodeErrorZ_free(self); }
-	CResult_NodeIdDecodeErrorZ& operator=(CResult_NodeIdDecodeErrorZ&& o) { CResult_NodeIdDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeIdDecodeErrorZ)); return *this; }
-	LDKCResult_NodeIdDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_NodeIdDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_NodeIdDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_NodeIdDecodeErrorZ* operator ->() const { return &self; }
+	CResult_BlindedPathDecodeErrorZ(const CResult_BlindedPathDecodeErrorZ&) = delete;
+	CResult_BlindedPathDecodeErrorZ(CResult_BlindedPathDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedPathDecodeErrorZ)); }
+	CResult_BlindedPathDecodeErrorZ(LDKCResult_BlindedPathDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedPathDecodeErrorZ)); }
+	operator LDKCResult_BlindedPathDecodeErrorZ() && { LDKCResult_BlindedPathDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedPathDecodeErrorZ)); return res; }
+	~CResult_BlindedPathDecodeErrorZ() { CResult_BlindedPathDecodeErrorZ_free(self); }
+	CResult_BlindedPathDecodeErrorZ& operator=(CResult_BlindedPathDecodeErrorZ&& o) { CResult_BlindedPathDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedPathDecodeErrorZ)); return *this; }
+	LDKCResult_BlindedPathDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_BlindedPathDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_BlindedPathDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_BlindedPathDecodeErrorZ* operator ->() const { return &self; }
 };
-class C2Tuple_BlockHashChannelMonitorZ {
+class CVec_ChannelMonitorZ {
 private:
-	LDKC2Tuple_BlockHashChannelMonitorZ self;
+	LDKCVec_ChannelMonitorZ 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; }
+	CVec_ChannelMonitorZ(const CVec_ChannelMonitorZ&) = delete;
+	CVec_ChannelMonitorZ(CVec_ChannelMonitorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ChannelMonitorZ)); }
+	CVec_ChannelMonitorZ(LDKCVec_ChannelMonitorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ChannelMonitorZ)); }
+	operator LDKCVec_ChannelMonitorZ() && { LDKCVec_ChannelMonitorZ res = self; memset(&self, 0, sizeof(LDKCVec_ChannelMonitorZ)); return res; }
+	~CVec_ChannelMonitorZ() { CVec_ChannelMonitorZ_free(self); }
+	CVec_ChannelMonitorZ& operator=(CVec_ChannelMonitorZ&& o) { CVec_ChannelMonitorZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ChannelMonitorZ)); return *this; }
+	LDKCVec_ChannelMonitorZ* operator &() { return &self; }
+	LDKCVec_ChannelMonitorZ* operator ->() { return &self; }
+	const LDKCVec_ChannelMonitorZ* operator &() const { return &self; }
+	const LDKCVec_ChannelMonitorZ* operator ->() const { return &self; }
 };
-class CResult_ShutdownScriptInvalidShutdownScriptZ {
+class CResult_RouteHopDecodeErrorZ {
 private:
-	LDKCResult_ShutdownScriptInvalidShutdownScriptZ self;
-public:
-	CResult_ShutdownScriptInvalidShutdownScriptZ(const CResult_ShutdownScriptInvalidShutdownScriptZ&) = delete;
-	CResult_ShutdownScriptInvalidShutdownScriptZ(CResult_ShutdownScriptInvalidShutdownScriptZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ShutdownScriptInvalidShutdownScriptZ)); }
-	CResult_ShutdownScriptInvalidShutdownScriptZ(LDKCResult_ShutdownScriptInvalidShutdownScriptZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ)); }
-	operator LDKCResult_ShutdownScriptInvalidShutdownScriptZ() && { LDKCResult_ShutdownScriptInvalidShutdownScriptZ res = self; memset(&self, 0, sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ)); return res; }
-	~CResult_ShutdownScriptInvalidShutdownScriptZ() { CResult_ShutdownScriptInvalidShutdownScriptZ_free(self); }
-	CResult_ShutdownScriptInvalidShutdownScriptZ& operator=(CResult_ShutdownScriptInvalidShutdownScriptZ&& o) { CResult_ShutdownScriptInvalidShutdownScriptZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ShutdownScriptInvalidShutdownScriptZ)); return *this; }
-	LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator &() { return &self; }
-	LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator ->() { return &self; }
-	const LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator &() const { return &self; }
-	const LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator ->() const { return &self; }
+	LDKCResult_RouteHopDecodeErrorZ self;
+public:
+	CResult_RouteHopDecodeErrorZ(const CResult_RouteHopDecodeErrorZ&) = delete;
+	CResult_RouteHopDecodeErrorZ(CResult_RouteHopDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteHopDecodeErrorZ)); }
+	CResult_RouteHopDecodeErrorZ(LDKCResult_RouteHopDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteHopDecodeErrorZ)); }
+	operator LDKCResult_RouteHopDecodeErrorZ() && { LDKCResult_RouteHopDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteHopDecodeErrorZ)); return res; }
+	~CResult_RouteHopDecodeErrorZ() { CResult_RouteHopDecodeErrorZ_free(self); }
+	CResult_RouteHopDecodeErrorZ& operator=(CResult_RouteHopDecodeErrorZ&& o) { CResult_RouteHopDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteHopDecodeErrorZ)); return *this; }
+	LDKCResult_RouteHopDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_RouteHopDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_RouteHopDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_RouteHopDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_NodeAnnouncementInfoDecodeErrorZ {
+class CVec_BalanceZ {
 private:
-	LDKCResult_NodeAnnouncementInfoDecodeErrorZ self;
+	LDKCVec_BalanceZ self;
 public:
-	CResult_NodeAnnouncementInfoDecodeErrorZ(const CResult_NodeAnnouncementInfoDecodeErrorZ&) = delete;
-	CResult_NodeAnnouncementInfoDecodeErrorZ(CResult_NodeAnnouncementInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeAnnouncementInfoDecodeErrorZ)); }
-	CResult_NodeAnnouncementInfoDecodeErrorZ(LDKCResult_NodeAnnouncementInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ)); }
-	operator LDKCResult_NodeAnnouncementInfoDecodeErrorZ() && { LDKCResult_NodeAnnouncementInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ)); return res; }
-	~CResult_NodeAnnouncementInfoDecodeErrorZ() { CResult_NodeAnnouncementInfoDecodeErrorZ_free(self); }
-	CResult_NodeAnnouncementInfoDecodeErrorZ& operator=(CResult_NodeAnnouncementInfoDecodeErrorZ&& o) { CResult_NodeAnnouncementInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeAnnouncementInfoDecodeErrorZ)); return *this; }
-	LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator ->() const { return &self; }
+	CVec_BalanceZ(const CVec_BalanceZ&) = delete;
+	CVec_BalanceZ(CVec_BalanceZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_BalanceZ)); }
+	CVec_BalanceZ(LDKCVec_BalanceZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_BalanceZ)); }
+	operator LDKCVec_BalanceZ() && { LDKCVec_BalanceZ res = self; memset(&self, 0, sizeof(LDKCVec_BalanceZ)); return res; }
+	~CVec_BalanceZ() { CVec_BalanceZ_free(self); }
+	CVec_BalanceZ& operator=(CVec_BalanceZ&& o) { CVec_BalanceZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_BalanceZ)); return *this; }
+	LDKCVec_BalanceZ* operator &() { return &self; }
+	LDKCVec_BalanceZ* operator ->() { return &self; }
+	const LDKCVec_BalanceZ* operator &() const { return &self; }
+	const LDKCVec_BalanceZ* operator ->() const { return &self; }
 };
-class CResult_COption_NetworkUpdateZDecodeErrorZ {
+class CResult_FundingSignedDecodeErrorZ {
 private:
-	LDKCResult_COption_NetworkUpdateZDecodeErrorZ self;
+	LDKCResult_FundingSignedDecodeErrorZ self;
 public:
-	CResult_COption_NetworkUpdateZDecodeErrorZ(const CResult_COption_NetworkUpdateZDecodeErrorZ&) = delete;
-	CResult_COption_NetworkUpdateZDecodeErrorZ(CResult_COption_NetworkUpdateZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_NetworkUpdateZDecodeErrorZ)); }
-	CResult_COption_NetworkUpdateZDecodeErrorZ(LDKCResult_COption_NetworkUpdateZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ)); }
-	operator LDKCResult_COption_NetworkUpdateZDecodeErrorZ() && { LDKCResult_COption_NetworkUpdateZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ)); return res; }
-	~CResult_COption_NetworkUpdateZDecodeErrorZ() { CResult_COption_NetworkUpdateZDecodeErrorZ_free(self); }
-	CResult_COption_NetworkUpdateZDecodeErrorZ& operator=(CResult_COption_NetworkUpdateZDecodeErrorZ&& o) { CResult_COption_NetworkUpdateZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_NetworkUpdateZDecodeErrorZ)); return *this; }
-	LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator ->() const { return &self; }
+	CResult_FundingSignedDecodeErrorZ(const CResult_FundingSignedDecodeErrorZ&) = delete;
+	CResult_FundingSignedDecodeErrorZ(CResult_FundingSignedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FundingSignedDecodeErrorZ)); }
+	CResult_FundingSignedDecodeErrorZ(LDKCResult_FundingSignedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FundingSignedDecodeErrorZ)); }
+	operator LDKCResult_FundingSignedDecodeErrorZ() && { LDKCResult_FundingSignedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FundingSignedDecodeErrorZ)); return res; }
+	~CResult_FundingSignedDecodeErrorZ() { CResult_FundingSignedDecodeErrorZ_free(self); }
+	CResult_FundingSignedDecodeErrorZ& operator=(CResult_FundingSignedDecodeErrorZ&& o) { CResult_FundingSignedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FundingSignedDecodeErrorZ)); return *this; }
+	LDKCResult_FundingSignedDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_FundingSignedDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_FundingSignedDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_FundingSignedDecodeErrorZ* operator ->() const { return &self; }
 };
 class CResult_RecoverableSignatureNoneZ {
 private:
@@ -4936,6 +7019,21 @@ public:
 	const LDKCResult_RecoverableSignatureNoneZ* operator &() const { return &self; }
 	const LDKCResult_RecoverableSignatureNoneZ* operator ->() const { return &self; }
 };
+class C2Tuple_Z {
+private:
+	LDKC2Tuple_Z self;
+public:
+	C2Tuple_Z(const C2Tuple_Z&) = delete;
+	C2Tuple_Z(C2Tuple_Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_Z)); }
+	C2Tuple_Z(LDKC2Tuple_Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_Z)); }
+	operator LDKC2Tuple_Z() && { LDKC2Tuple_Z res = self; memset(&self, 0, sizeof(LDKC2Tuple_Z)); return res; }
+	~C2Tuple_Z() { C2Tuple_Z_free(self); }
+	C2Tuple_Z& operator=(C2Tuple_Z&& o) { C2Tuple_Z_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_Z)); return *this; }
+	LDKC2Tuple_Z* operator &() { return &self; }
+	LDKC2Tuple_Z* operator ->() { return &self; }
+	const LDKC2Tuple_Z* operator &() const { return &self; }
+	const LDKC2Tuple_Z* operator ->() const { return &self; }
+};
 class C3Tuple_RawInvoice_u832InvoiceSignatureZ {
 private:
 	LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ self;
@@ -4951,36 +7049,6 @@ public:
 	const LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* operator &() const { return &self; }
 	const LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* operator ->() const { return &self; }
 };
-class CVec_UpdateFailMalformedHTLCZ {
-private:
-	LDKCVec_UpdateFailMalformedHTLCZ self;
-public:
-	CVec_UpdateFailMalformedHTLCZ(const CVec_UpdateFailMalformedHTLCZ&) = delete;
-	CVec_UpdateFailMalformedHTLCZ(CVec_UpdateFailMalformedHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateFailMalformedHTLCZ)); }
-	CVec_UpdateFailMalformedHTLCZ(LDKCVec_UpdateFailMalformedHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateFailMalformedHTLCZ)); }
-	operator LDKCVec_UpdateFailMalformedHTLCZ() && { LDKCVec_UpdateFailMalformedHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateFailMalformedHTLCZ)); return res; }
-	~CVec_UpdateFailMalformedHTLCZ() { CVec_UpdateFailMalformedHTLCZ_free(self); }
-	CVec_UpdateFailMalformedHTLCZ& operator=(CVec_UpdateFailMalformedHTLCZ&& o) { CVec_UpdateFailMalformedHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateFailMalformedHTLCZ)); return *this; }
-	LDKCVec_UpdateFailMalformedHTLCZ* operator &() { return &self; }
-	LDKCVec_UpdateFailMalformedHTLCZ* operator ->() { return &self; }
-	const LDKCVec_UpdateFailMalformedHTLCZ* operator &() const { return &self; }
-	const LDKCVec_UpdateFailMalformedHTLCZ* operator ->() const { return &self; }
-};
-class CResult_FundingSignedDecodeErrorZ {
-private:
-	LDKCResult_FundingSignedDecodeErrorZ self;
-public:
-	CResult_FundingSignedDecodeErrorZ(const CResult_FundingSignedDecodeErrorZ&) = delete;
-	CResult_FundingSignedDecodeErrorZ(CResult_FundingSignedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FundingSignedDecodeErrorZ)); }
-	CResult_FundingSignedDecodeErrorZ(LDKCResult_FundingSignedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FundingSignedDecodeErrorZ)); }
-	operator LDKCResult_FundingSignedDecodeErrorZ() && { LDKCResult_FundingSignedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FundingSignedDecodeErrorZ)); return res; }
-	~CResult_FundingSignedDecodeErrorZ() { CResult_FundingSignedDecodeErrorZ_free(self); }
-	CResult_FundingSignedDecodeErrorZ& operator=(CResult_FundingSignedDecodeErrorZ&& o) { CResult_FundingSignedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FundingSignedDecodeErrorZ)); return *this; }
-	LDKCResult_FundingSignedDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_FundingSignedDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_FundingSignedDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_FundingSignedDecodeErrorZ* operator ->() const { return &self; }
-};
 class CResult_NetworkGraphDecodeErrorZ {
 private:
 	LDKCResult_NetworkGraphDecodeErrorZ self;
@@ -4996,36 +7064,6 @@ public:
 	const LDKCResult_NetworkGraphDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_NetworkGraphDecodeErrorZ* operator ->() const { return &self; }
 };
-class CVec_RouteHopZ {
-private:
-	LDKCVec_RouteHopZ self;
-public:
-	CVec_RouteHopZ(const CVec_RouteHopZ&) = delete;
-	CVec_RouteHopZ(CVec_RouteHopZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RouteHopZ)); }
-	CVec_RouteHopZ(LDKCVec_RouteHopZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RouteHopZ)); }
-	operator LDKCVec_RouteHopZ() && { LDKCVec_RouteHopZ res = self; memset(&self, 0, sizeof(LDKCVec_RouteHopZ)); return res; }
-	~CVec_RouteHopZ() { CVec_RouteHopZ_free(self); }
-	CVec_RouteHopZ& operator=(CVec_RouteHopZ&& o) { CVec_RouteHopZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_RouteHopZ)); return *this; }
-	LDKCVec_RouteHopZ* operator &() { return &self; }
-	LDKCVec_RouteHopZ* operator ->() { return &self; }
-	const LDKCVec_RouteHopZ* operator &() const { return &self; }
-	const LDKCVec_RouteHopZ* 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 CResult_NodeInfoDecodeErrorZ {
 private:
 	LDKCResult_NodeInfoDecodeErrorZ self;
@@ -5041,6 +7079,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 +7124,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;
@@ -5101,50 +7139,20 @@ public:
 	const LDKCVec_u8Z* operator &() const { return &self; }
 	const LDKCVec_u8Z* operator ->() const { return &self; }
 };
-class CVec_C2Tuple_BlockHashChannelMonitorZZ {
-private:
-	LDKCVec_C2Tuple_BlockHashChannelMonitorZZ self;
-public:
-	CVec_C2Tuple_BlockHashChannelMonitorZZ(const CVec_C2Tuple_BlockHashChannelMonitorZZ&) = delete;
-	CVec_C2Tuple_BlockHashChannelMonitorZZ(CVec_C2Tuple_BlockHashChannelMonitorZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_BlockHashChannelMonitorZZ)); }
-	CVec_C2Tuple_BlockHashChannelMonitorZZ(LDKCVec_C2Tuple_BlockHashChannelMonitorZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_BlockHashChannelMonitorZZ)); }
-	operator LDKCVec_C2Tuple_BlockHashChannelMonitorZZ() && { LDKCVec_C2Tuple_BlockHashChannelMonitorZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_BlockHashChannelMonitorZZ)); return res; }
-	~CVec_C2Tuple_BlockHashChannelMonitorZZ() { CVec_C2Tuple_BlockHashChannelMonitorZZ_free(self); }
-	CVec_C2Tuple_BlockHashChannelMonitorZZ& operator=(CVec_C2Tuple_BlockHashChannelMonitorZZ&& o) { CVec_C2Tuple_BlockHashChannelMonitorZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_BlockHashChannelMonitorZZ)); return *this; }
-	LDKCVec_C2Tuple_BlockHashChannelMonitorZZ* operator &() { return &self; }
-	LDKCVec_C2Tuple_BlockHashChannelMonitorZZ* operator ->() { return &self; }
-	const LDKCVec_C2Tuple_BlockHashChannelMonitorZZ* operator &() const { return &self; }
-	const LDKCVec_C2Tuple_BlockHashChannelMonitorZZ* operator ->() const { return &self; }
-};
-class CVec_ThirtyTwoBytesZ {
-private:
-	LDKCVec_ThirtyTwoBytesZ self;
-public:
-	CVec_ThirtyTwoBytesZ(const CVec_ThirtyTwoBytesZ&) = delete;
-	CVec_ThirtyTwoBytesZ(CVec_ThirtyTwoBytesZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ThirtyTwoBytesZ)); }
-	CVec_ThirtyTwoBytesZ(LDKCVec_ThirtyTwoBytesZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ThirtyTwoBytesZ)); }
-	operator LDKCVec_ThirtyTwoBytesZ() && { LDKCVec_ThirtyTwoBytesZ res = self; memset(&self, 0, sizeof(LDKCVec_ThirtyTwoBytesZ)); return res; }
-	~CVec_ThirtyTwoBytesZ() { CVec_ThirtyTwoBytesZ_free(self); }
-	CVec_ThirtyTwoBytesZ& operator=(CVec_ThirtyTwoBytesZ&& o) { CVec_ThirtyTwoBytesZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ThirtyTwoBytesZ)); return *this; }
-	LDKCVec_ThirtyTwoBytesZ* operator &() { return &self; }
-	LDKCVec_ThirtyTwoBytesZ* operator ->() { return &self; }
-	const LDKCVec_ThirtyTwoBytesZ* operator &() const { return &self; }
-	const LDKCVec_ThirtyTwoBytesZ* operator ->() const { return &self; }
-};
-class CResult_ClosingSignedDecodeErrorZ {
+class CResult_NonePaymentSendFailureZ {
 private:
-	LDKCResult_ClosingSignedDecodeErrorZ self;
+	LDKCResult_NonePaymentSendFailureZ self;
 public:
-	CResult_ClosingSignedDecodeErrorZ(const CResult_ClosingSignedDecodeErrorZ&) = delete;
-	CResult_ClosingSignedDecodeErrorZ(CResult_ClosingSignedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ClosingSignedDecodeErrorZ)); }
-	CResult_ClosingSignedDecodeErrorZ(LDKCResult_ClosingSignedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ClosingSignedDecodeErrorZ)); }
-	operator LDKCResult_ClosingSignedDecodeErrorZ() && { LDKCResult_ClosingSignedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ClosingSignedDecodeErrorZ)); return res; }
-	~CResult_ClosingSignedDecodeErrorZ() { CResult_ClosingSignedDecodeErrorZ_free(self); }
-	CResult_ClosingSignedDecodeErrorZ& operator=(CResult_ClosingSignedDecodeErrorZ&& o) { CResult_ClosingSignedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ClosingSignedDecodeErrorZ)); return *this; }
-	LDKCResult_ClosingSignedDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_ClosingSignedDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_ClosingSignedDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_ClosingSignedDecodeErrorZ* operator ->() const { return &self; }
+	CResult_NonePaymentSendFailureZ(const CResult_NonePaymentSendFailureZ&) = delete;
+	CResult_NonePaymentSendFailureZ(CResult_NonePaymentSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NonePaymentSendFailureZ)); }
+	CResult_NonePaymentSendFailureZ(LDKCResult_NonePaymentSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NonePaymentSendFailureZ)); }
+	operator LDKCResult_NonePaymentSendFailureZ() && { LDKCResult_NonePaymentSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_NonePaymentSendFailureZ)); return res; }
+	~CResult_NonePaymentSendFailureZ() { CResult_NonePaymentSendFailureZ_free(self); }
+	CResult_NonePaymentSendFailureZ& operator=(CResult_NonePaymentSendFailureZ&& o) { CResult_NonePaymentSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NonePaymentSendFailureZ)); return *this; }
+	LDKCResult_NonePaymentSendFailureZ* operator &() { return &self; }
+	LDKCResult_NonePaymentSendFailureZ* operator ->() { return &self; }
+	const LDKCResult_NonePaymentSendFailureZ* operator &() const { return &self; }
+	const LDKCResult_NonePaymentSendFailureZ* operator ->() const { return &self; }
 };
 class CResult_HolderCommitmentTransactionDecodeErrorZ {
 private:
@@ -5161,51 +7169,6 @@ public:
 	const LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator ->() const { return &self; }
 };
-class CVec_CResult_NoneAPIErrorZZ {
-private:
-	LDKCVec_CResult_NoneAPIErrorZZ self;
-public:
-	CVec_CResult_NoneAPIErrorZZ(const CVec_CResult_NoneAPIErrorZZ&) = delete;
-	CVec_CResult_NoneAPIErrorZZ(CVec_CResult_NoneAPIErrorZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_CResult_NoneAPIErrorZZ)); }
-	CVec_CResult_NoneAPIErrorZZ(LDKCVec_CResult_NoneAPIErrorZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_CResult_NoneAPIErrorZZ)); }
-	operator LDKCVec_CResult_NoneAPIErrorZZ() && { LDKCVec_CResult_NoneAPIErrorZZ res = self; memset(&self, 0, sizeof(LDKCVec_CResult_NoneAPIErrorZZ)); return res; }
-	~CVec_CResult_NoneAPIErrorZZ() { CVec_CResult_NoneAPIErrorZZ_free(self); }
-	CVec_CResult_NoneAPIErrorZZ& operator=(CVec_CResult_NoneAPIErrorZZ&& o) { CVec_CResult_NoneAPIErrorZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_CResult_NoneAPIErrorZZ)); return *this; }
-	LDKCVec_CResult_NoneAPIErrorZZ* operator &() { return &self; }
-	LDKCVec_CResult_NoneAPIErrorZZ* operator ->() { return &self; }
-	const LDKCVec_CResult_NoneAPIErrorZZ* operator &() const { return &self; }
-	const LDKCVec_CResult_NoneAPIErrorZZ* operator ->() const { return &self; }
-};
-class CResult_CounterpartyCommitmentSecretsDecodeErrorZ {
-private:
-	LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ self;
-public:
-	CResult_CounterpartyCommitmentSecretsDecodeErrorZ(const CResult_CounterpartyCommitmentSecretsDecodeErrorZ&) = delete;
-	CResult_CounterpartyCommitmentSecretsDecodeErrorZ(CResult_CounterpartyCommitmentSecretsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CounterpartyCommitmentSecretsDecodeErrorZ)); }
-	CResult_CounterpartyCommitmentSecretsDecodeErrorZ(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ)); }
-	operator LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ() && { LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ)); return res; }
-	~CResult_CounterpartyCommitmentSecretsDecodeErrorZ() { CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(self); }
-	CResult_CounterpartyCommitmentSecretsDecodeErrorZ& operator=(CResult_CounterpartyCommitmentSecretsDecodeErrorZ&& o) { CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CounterpartyCommitmentSecretsDecodeErrorZ)); return *this; }
-	LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_ChannelCounterpartyDecodeErrorZ {
-private:
-	LDKCResult_ChannelCounterpartyDecodeErrorZ self;
-public:
-	CResult_ChannelCounterpartyDecodeErrorZ(const CResult_ChannelCounterpartyDecodeErrorZ&) = delete;
-	CResult_ChannelCounterpartyDecodeErrorZ(CResult_ChannelCounterpartyDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelCounterpartyDecodeErrorZ)); }
-	CResult_ChannelCounterpartyDecodeErrorZ(LDKCResult_ChannelCounterpartyDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ)); }
-	operator LDKCResult_ChannelCounterpartyDecodeErrorZ() && { LDKCResult_ChannelCounterpartyDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ)); return res; }
-	~CResult_ChannelCounterpartyDecodeErrorZ() { CResult_ChannelCounterpartyDecodeErrorZ_free(self); }
-	CResult_ChannelCounterpartyDecodeErrorZ& operator=(CResult_ChannelCounterpartyDecodeErrorZ&& o) { CResult_ChannelCounterpartyDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelCounterpartyDecodeErrorZ)); return *this; }
-	LDKCResult_ChannelCounterpartyDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_ChannelCounterpartyDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_ChannelCounterpartyDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_ChannelCounterpartyDecodeErrorZ* operator ->() const { return &self; }
-};
 class CResult_WarningMessageDecodeErrorZ {
 private:
 	LDKCResult_WarningMessageDecodeErrorZ self;
@@ -5221,6 +7184,21 @@ public:
 	const LDKCResult_WarningMessageDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_WarningMessageDecodeErrorZ* operator ->() const { return &self; }
 };
+class CResult_ChannelCounterpartyDecodeErrorZ {
+private:
+	LDKCResult_ChannelCounterpartyDecodeErrorZ self;
+public:
+	CResult_ChannelCounterpartyDecodeErrorZ(const CResult_ChannelCounterpartyDecodeErrorZ&) = delete;
+	CResult_ChannelCounterpartyDecodeErrorZ(CResult_ChannelCounterpartyDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelCounterpartyDecodeErrorZ)); }
+	CResult_ChannelCounterpartyDecodeErrorZ(LDKCResult_ChannelCounterpartyDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ)); }
+	operator LDKCResult_ChannelCounterpartyDecodeErrorZ() && { LDKCResult_ChannelCounterpartyDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ)); return res; }
+	~CResult_ChannelCounterpartyDecodeErrorZ() { CResult_ChannelCounterpartyDecodeErrorZ_free(self); }
+	CResult_ChannelCounterpartyDecodeErrorZ& operator=(CResult_ChannelCounterpartyDecodeErrorZ&& o) { CResult_ChannelCounterpartyDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelCounterpartyDecodeErrorZ)); return *this; }
+	LDKCResult_ChannelCounterpartyDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_ChannelCounterpartyDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_ChannelCounterpartyDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_ChannelCounterpartyDecodeErrorZ* operator ->() const { return &self; }
+};
 class CResult_SignatureNoneZ {
 private:
 	LDKCResult_SignatureNoneZ self;
@@ -5236,51 +7214,6 @@ public:
 	const LDKCResult_SignatureNoneZ* operator &() const { return &self; }
 	const LDKCResult_SignatureNoneZ* operator ->() const { return &self; }
 };
-class CVec_RouteHintHopZ {
-private:
-	LDKCVec_RouteHintHopZ self;
-public:
-	CVec_RouteHintHopZ(const CVec_RouteHintHopZ&) = delete;
-	CVec_RouteHintHopZ(CVec_RouteHintHopZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RouteHintHopZ)); }
-	CVec_RouteHintHopZ(LDKCVec_RouteHintHopZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RouteHintHopZ)); }
-	operator LDKCVec_RouteHintHopZ() && { LDKCVec_RouteHintHopZ res = self; memset(&self, 0, sizeof(LDKCVec_RouteHintHopZ)); return res; }
-	~CVec_RouteHintHopZ() { CVec_RouteHintHopZ_free(self); }
-	CVec_RouteHintHopZ& operator=(CVec_RouteHintHopZ&& o) { CVec_RouteHintHopZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_RouteHintHopZ)); return *this; }
-	LDKCVec_RouteHintHopZ* operator &() { return &self; }
-	LDKCVec_RouteHintHopZ* operator ->() { return &self; }
-	const LDKCVec_RouteHintHopZ* operator &() const { return &self; }
-	const LDKCVec_RouteHintHopZ* operator ->() const { return &self; }
-};
-class CResult_SecretKeyNoneZ {
-private:
-	LDKCResult_SecretKeyNoneZ self;
-public:
-	CResult_SecretKeyNoneZ(const CResult_SecretKeyNoneZ&) = delete;
-	CResult_SecretKeyNoneZ(CResult_SecretKeyNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SecretKeyNoneZ)); }
-	CResult_SecretKeyNoneZ(LDKCResult_SecretKeyNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SecretKeyNoneZ)); }
-	operator LDKCResult_SecretKeyNoneZ() && { LDKCResult_SecretKeyNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_SecretKeyNoneZ)); return res; }
-	~CResult_SecretKeyNoneZ() { CResult_SecretKeyNoneZ_free(self); }
-	CResult_SecretKeyNoneZ& operator=(CResult_SecretKeyNoneZ&& o) { CResult_SecretKeyNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SecretKeyNoneZ)); return *this; }
-	LDKCResult_SecretKeyNoneZ* operator &() { return &self; }
-	LDKCResult_SecretKeyNoneZ* operator ->() { return &self; }
-	const LDKCResult_SecretKeyNoneZ* operator &() const { return &self; }
-	const LDKCResult_SecretKeyNoneZ* operator ->() const { return &self; }
-};
-class CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ {
-private:
-	LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ self;
-public:
-	CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ(const CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ&) = delete;
-	CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ(CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ)); }
-	CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ)); }
-	operator LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ() && { LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ)); return res; }
-	~CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ() { CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(self); }
-	CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ& operator=(CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ&& o) { CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ)); return *this; }
-	LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* operator &() { return &self; }
-	LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* operator ->() { return &self; }
-	const LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* operator &() const { return &self; }
-	const LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* operator ->() const { return &self; }
-};
 class C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ {
 private:
 	LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ self;
@@ -5296,20 +7229,35 @@ public:
 	const LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* operator &() const { return &self; }
 	const LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* operator ->() const { return &self; }
 };
-class CResult_PaymentParametersDecodeErrorZ {
+class CResult_InitDecodeErrorZ {
 private:
-	LDKCResult_PaymentParametersDecodeErrorZ self;
+	LDKCResult_InitDecodeErrorZ self;
 public:
-	CResult_PaymentParametersDecodeErrorZ(const CResult_PaymentParametersDecodeErrorZ&) = delete;
-	CResult_PaymentParametersDecodeErrorZ(CResult_PaymentParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentParametersDecodeErrorZ)); }
-	CResult_PaymentParametersDecodeErrorZ(LDKCResult_PaymentParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentParametersDecodeErrorZ)); }
-	operator LDKCResult_PaymentParametersDecodeErrorZ() && { LDKCResult_PaymentParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentParametersDecodeErrorZ)); return res; }
-	~CResult_PaymentParametersDecodeErrorZ() { CResult_PaymentParametersDecodeErrorZ_free(self); }
-	CResult_PaymentParametersDecodeErrorZ& operator=(CResult_PaymentParametersDecodeErrorZ&& o) { CResult_PaymentParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentParametersDecodeErrorZ)); return *this; }
-	LDKCResult_PaymentParametersDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_PaymentParametersDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_PaymentParametersDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_PaymentParametersDecodeErrorZ* operator ->() const { return &self; }
+	CResult_InitDecodeErrorZ(const CResult_InitDecodeErrorZ&) = delete;
+	CResult_InitDecodeErrorZ(CResult_InitDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InitDecodeErrorZ)); }
+	CResult_InitDecodeErrorZ(LDKCResult_InitDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InitDecodeErrorZ)); }
+	operator LDKCResult_InitDecodeErrorZ() && { LDKCResult_InitDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InitDecodeErrorZ)); return res; }
+	~CResult_InitDecodeErrorZ() { CResult_InitDecodeErrorZ_free(self); }
+	CResult_InitDecodeErrorZ& operator=(CResult_InitDecodeErrorZ&& o) { CResult_InitDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InitDecodeErrorZ)); return *this; }
+	LDKCResult_InitDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_InitDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_InitDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_InitDecodeErrorZ* operator ->() const { return &self; }
+};
+class CVec_MonitorUpdateIdZ {
+private:
+	LDKCVec_MonitorUpdateIdZ self;
+public:
+	CVec_MonitorUpdateIdZ(const CVec_MonitorUpdateIdZ&) = delete;
+	CVec_MonitorUpdateIdZ(CVec_MonitorUpdateIdZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_MonitorUpdateIdZ)); }
+	CVec_MonitorUpdateIdZ(LDKCVec_MonitorUpdateIdZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_MonitorUpdateIdZ)); }
+	operator LDKCVec_MonitorUpdateIdZ() && { LDKCVec_MonitorUpdateIdZ res = self; memset(&self, 0, sizeof(LDKCVec_MonitorUpdateIdZ)); return res; }
+	~CVec_MonitorUpdateIdZ() { CVec_MonitorUpdateIdZ_free(self); }
+	CVec_MonitorUpdateIdZ& operator=(CVec_MonitorUpdateIdZ&& o) { CVec_MonitorUpdateIdZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_MonitorUpdateIdZ)); return *this; }
+	LDKCVec_MonitorUpdateIdZ* operator &() { return &self; }
+	LDKCVec_MonitorUpdateIdZ* operator ->() { return &self; }
+	const LDKCVec_MonitorUpdateIdZ* operator &() const { return &self; }
+	const LDKCVec_MonitorUpdateIdZ* operator ->() const { return &self; }
 };
 class CResult_PaymentPurposeDecodeErrorZ {
 private:
@@ -5326,21 +7274,6 @@ public:
 	const LDKCResult_PaymentPurposeDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_PaymentPurposeDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_InitDecodeErrorZ {
-private:
-	LDKCResult_InitDecodeErrorZ self;
-public:
-	CResult_InitDecodeErrorZ(const CResult_InitDecodeErrorZ&) = delete;
-	CResult_InitDecodeErrorZ(CResult_InitDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InitDecodeErrorZ)); }
-	CResult_InitDecodeErrorZ(LDKCResult_InitDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InitDecodeErrorZ)); }
-	operator LDKCResult_InitDecodeErrorZ() && { LDKCResult_InitDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InitDecodeErrorZ)); return res; }
-	~CResult_InitDecodeErrorZ() { CResult_InitDecodeErrorZ_free(self); }
-	CResult_InitDecodeErrorZ& operator=(CResult_InitDecodeErrorZ&& o) { CResult_InitDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InitDecodeErrorZ)); return *this; }
-	LDKCResult_InitDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_InitDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_InitDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_InitDecodeErrorZ* operator ->() const { return &self; }
-};
 class CResult_OutPointDecodeErrorZ {
 private:
 	LDKCResult_OutPointDecodeErrorZ self;
@@ -5371,36 +7304,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;
@@ -5461,36 +7364,6 @@ public:
 	const LDKCResult_RouteHintHopDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_RouteHintHopDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_C2Tuple_SignatureSignatureZNoneZ {
-private:
-	LDKCResult_C2Tuple_SignatureSignatureZNoneZ self;
-public:
-	CResult_C2Tuple_SignatureSignatureZNoneZ(const CResult_C2Tuple_SignatureSignatureZNoneZ&) = delete;
-	CResult_C2Tuple_SignatureSignatureZNoneZ(CResult_C2Tuple_SignatureSignatureZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_SignatureSignatureZNoneZ)); }
-	CResult_C2Tuple_SignatureSignatureZNoneZ(LDKCResult_C2Tuple_SignatureSignatureZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_SignatureSignatureZNoneZ)); }
-	operator LDKCResult_C2Tuple_SignatureSignatureZNoneZ() && { LDKCResult_C2Tuple_SignatureSignatureZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_SignatureSignatureZNoneZ)); return res; }
-	~CResult_C2Tuple_SignatureSignatureZNoneZ() { CResult_C2Tuple_SignatureSignatureZNoneZ_free(self); }
-	CResult_C2Tuple_SignatureSignatureZNoneZ& operator=(CResult_C2Tuple_SignatureSignatureZNoneZ&& o) { CResult_C2Tuple_SignatureSignatureZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_SignatureSignatureZNoneZ)); return *this; }
-	LDKCResult_C2Tuple_SignatureSignatureZNoneZ* operator &() { return &self; }
-	LDKCResult_C2Tuple_SignatureSignatureZNoneZ* operator ->() { return &self; }
-	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,50 +7379,20 @@ public:
 	const LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_UnsignedChannelAnnouncementDecodeErrorZ {
-private:
-	LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ 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; }
-};
-class CVec_TxidZ {
+class CResult_SharedSecretNoneZ {
 private:
-	LDKCVec_TxidZ self;
+	LDKCResult_SharedSecretNoneZ self;
 public:
-	CVec_TxidZ(const CVec_TxidZ&) = delete;
-	CVec_TxidZ(CVec_TxidZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TxidZ)); }
-	CVec_TxidZ(LDKCVec_TxidZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TxidZ)); }
-	operator LDKCVec_TxidZ() && { LDKCVec_TxidZ res = self; memset(&self, 0, sizeof(LDKCVec_TxidZ)); return res; }
-	~CVec_TxidZ() { CVec_TxidZ_free(self); }
-	CVec_TxidZ& operator=(CVec_TxidZ&& o) { CVec_TxidZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TxidZ)); return *this; }
-	LDKCVec_TxidZ* operator &() { return &self; }
-	LDKCVec_TxidZ* operator ->() { return &self; }
-	const LDKCVec_TxidZ* operator &() const { return &self; }
-	const LDKCVec_TxidZ* operator ->() const { return &self; }
-};
-class COption_AccessZ {
-private:
-	LDKCOption_AccessZ self;
-public:
-	COption_AccessZ(const COption_AccessZ&) = delete;
-	COption_AccessZ(COption_AccessZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_AccessZ)); }
-	COption_AccessZ(LDKCOption_AccessZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_AccessZ)); }
-	operator LDKCOption_AccessZ() && { LDKCOption_AccessZ res = self; memset(&self, 0, sizeof(LDKCOption_AccessZ)); return res; }
-	~COption_AccessZ() { COption_AccessZ_free(self); }
-	COption_AccessZ& operator=(COption_AccessZ&& o) { COption_AccessZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_AccessZ)); return *this; }
-	LDKCOption_AccessZ* operator &() { return &self; }
-	LDKCOption_AccessZ* operator ->() { return &self; }
-	const LDKCOption_AccessZ* operator &() const { return &self; }
-	const LDKCOption_AccessZ* 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 CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ {
 private:
@@ -5566,36 +7409,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;
-public:
-	CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ(const CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ&) = delete;
-	CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ(CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ)); }
-	CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ)); }
-	operator LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ() && { LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ)); return res; }
-	~CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ() { CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(self); }
-	CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ& operator=(CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ&& o) { CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ)); return *this; }
-	LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* operator ->() const { return &self; }
-};
 class CResult_CVec_CVec_u8ZZNoneZ {
 private:
 	LDKCResult_CVec_CVec_u8ZZNoneZ self;
@@ -5611,21 +7424,6 @@ public:
 	const LDKCResult_CVec_CVec_u8ZZNoneZ* operator &() const { return &self; }
 	const LDKCResult_CVec_CVec_u8ZZNoneZ* operator ->() const { return &self; }
 };
-class C2Tuple_SignatureSignatureZ {
-private:
-	LDKC2Tuple_SignatureSignatureZ self;
-public:
-	C2Tuple_SignatureSignatureZ(const C2Tuple_SignatureSignatureZ&) = delete;
-	C2Tuple_SignatureSignatureZ(C2Tuple_SignatureSignatureZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_SignatureSignatureZ)); }
-	C2Tuple_SignatureSignatureZ(LDKC2Tuple_SignatureSignatureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_SignatureSignatureZ)); }
-	operator LDKC2Tuple_SignatureSignatureZ() && { LDKC2Tuple_SignatureSignatureZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_SignatureSignatureZ)); return res; }
-	~C2Tuple_SignatureSignatureZ() { C2Tuple_SignatureSignatureZ_free(self); }
-	C2Tuple_SignatureSignatureZ& operator=(C2Tuple_SignatureSignatureZ&& o) { C2Tuple_SignatureSignatureZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_SignatureSignatureZ)); return *this; }
-	LDKC2Tuple_SignatureSignatureZ* operator &() { return &self; }
-	LDKC2Tuple_SignatureSignatureZ* operator ->() { return &self; }
-	const LDKC2Tuple_SignatureSignatureZ* operator &() const { return &self; }
-	const LDKC2Tuple_SignatureSignatureZ* operator ->() const { return &self; }
-};
 class C2Tuple_PaymentHashPaymentSecretZ {
 private:
 	LDKC2Tuple_PaymentHashPaymentSecretZ self;
@@ -5641,36 +7439,6 @@ public:
 	const LDKC2Tuple_PaymentHashPaymentSecretZ* operator &() const { return &self; }
 	const LDKC2Tuple_PaymentHashPaymentSecretZ* operator ->() const { return &self; }
 };
-class C2Tuple_BlockHashChannelManagerZ {
-private:
-	LDKC2Tuple_BlockHashChannelManagerZ self;
-public:
-	C2Tuple_BlockHashChannelManagerZ(const C2Tuple_BlockHashChannelManagerZ&) = delete;
-	C2Tuple_BlockHashChannelManagerZ(C2Tuple_BlockHashChannelManagerZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_BlockHashChannelManagerZ)); }
-	C2Tuple_BlockHashChannelManagerZ(LDKC2Tuple_BlockHashChannelManagerZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_BlockHashChannelManagerZ)); }
-	operator LDKC2Tuple_BlockHashChannelManagerZ() && { LDKC2Tuple_BlockHashChannelManagerZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_BlockHashChannelManagerZ)); return res; }
-	~C2Tuple_BlockHashChannelManagerZ() { C2Tuple_BlockHashChannelManagerZ_free(self); }
-	C2Tuple_BlockHashChannelManagerZ& operator=(C2Tuple_BlockHashChannelManagerZ&& o) { C2Tuple_BlockHashChannelManagerZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_BlockHashChannelManagerZ)); return *this; }
-	LDKC2Tuple_BlockHashChannelManagerZ* operator &() { return &self; }
-	LDKC2Tuple_BlockHashChannelManagerZ* operator ->() { return &self; }
-	const LDKC2Tuple_BlockHashChannelManagerZ* operator &() const { return &self; }
-	const LDKC2Tuple_BlockHashChannelManagerZ* operator ->() const { return &self; }
-};
-class CResult_ChannelTransactionParametersDecodeErrorZ {
-private:
-	LDKCResult_ChannelTransactionParametersDecodeErrorZ self;
-public:
-	CResult_ChannelTransactionParametersDecodeErrorZ(const CResult_ChannelTransactionParametersDecodeErrorZ&) = delete;
-	CResult_ChannelTransactionParametersDecodeErrorZ(CResult_ChannelTransactionParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelTransactionParametersDecodeErrorZ)); }
-	CResult_ChannelTransactionParametersDecodeErrorZ(LDKCResult_ChannelTransactionParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ)); }
-	operator LDKCResult_ChannelTransactionParametersDecodeErrorZ() && { LDKCResult_ChannelTransactionParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ)); return res; }
-	~CResult_ChannelTransactionParametersDecodeErrorZ() { CResult_ChannelTransactionParametersDecodeErrorZ_free(self); }
-	CResult_ChannelTransactionParametersDecodeErrorZ& operator=(CResult_ChannelTransactionParametersDecodeErrorZ&& o) { CResult_ChannelTransactionParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelTransactionParametersDecodeErrorZ)); return *this; }
-	LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator ->() const { return &self; }
-};
 class CResult_AcceptChannelDecodeErrorZ {
 private:
 	LDKCResult_AcceptChannelDecodeErrorZ self;
@@ -5686,110 +7454,35 @@ public:
 	const LDKCResult_AcceptChannelDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_AcceptChannelDecodeErrorZ* operator ->() const { return &self; }
 };
-class CVec_SignatureZ {
-private:
-	LDKCVec_SignatureZ self;
-public:
-	CVec_SignatureZ(const CVec_SignatureZ&) = delete;
-	CVec_SignatureZ(CVec_SignatureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_SignatureZ)); }
-	CVec_SignatureZ(LDKCVec_SignatureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_SignatureZ)); }
-	operator LDKCVec_SignatureZ() && { LDKCVec_SignatureZ res = self; memset(&self, 0, sizeof(LDKCVec_SignatureZ)); return res; }
-	~CVec_SignatureZ() { CVec_SignatureZ_free(self); }
-	CVec_SignatureZ& operator=(CVec_SignatureZ&& o) { CVec_SignatureZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_SignatureZ)); return *this; }
-	LDKCVec_SignatureZ* operator &() { return &self; }
-	LDKCVec_SignatureZ* operator ->() { return &self; }
-	const LDKCVec_SignatureZ* operator &() const { return &self; }
-	const LDKCVec_SignatureZ* operator ->() const { return &self; }
-};
-class CVec_u64Z {
-private:
-	LDKCVec_u64Z self;
-public:
-	CVec_u64Z(const CVec_u64Z&) = delete;
-	CVec_u64Z(CVec_u64Z&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_u64Z)); }
-	CVec_u64Z(LDKCVec_u64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_u64Z)); }
-	operator LDKCVec_u64Z() && { LDKCVec_u64Z res = self; memset(&self, 0, sizeof(LDKCVec_u64Z)); return res; }
-	~CVec_u64Z() { CVec_u64Z_free(self); }
-	CVec_u64Z& operator=(CVec_u64Z&& o) { CVec_u64Z_free(self); self = o.self; memset(&o, 0, sizeof(CVec_u64Z)); return *this; }
-	LDKCVec_u64Z* operator &() { return &self; }
-	LDKCVec_u64Z* operator ->() { return &self; }
-	const LDKCVec_u64Z* operator &() const { return &self; }
-	const LDKCVec_u64Z* 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_DelayedPaymentOutputDescriptorDecodeErrorZ {
-private:
-	LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ self;
-public:
-	CResult_DelayedPaymentOutputDescriptorDecodeErrorZ(const CResult_DelayedPaymentOutputDescriptorDecodeErrorZ&) = delete;
-	CResult_DelayedPaymentOutputDescriptorDecodeErrorZ(CResult_DelayedPaymentOutputDescriptorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_DelayedPaymentOutputDescriptorDecodeErrorZ)); }
-	CResult_DelayedPaymentOutputDescriptorDecodeErrorZ(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ)); }
-	operator LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ() && { LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ)); return res; }
-	~CResult_DelayedPaymentOutputDescriptorDecodeErrorZ() { CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(self); }
-	CResult_DelayedPaymentOutputDescriptorDecodeErrorZ& operator=(CResult_DelayedPaymentOutputDescriptorDecodeErrorZ&& o) { CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_DelayedPaymentOutputDescriptorDecodeErrorZ)); return *this; }
-	LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator ->() const { return &self; }
-};
-class C2Tuple_PaymentHashPaymentIdZ {
-private:
-	LDKC2Tuple_PaymentHashPaymentIdZ self;
-public:
-	C2Tuple_PaymentHashPaymentIdZ(const C2Tuple_PaymentHashPaymentIdZ&) = delete;
-	C2Tuple_PaymentHashPaymentIdZ(C2Tuple_PaymentHashPaymentIdZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_PaymentHashPaymentIdZ)); }
-	C2Tuple_PaymentHashPaymentIdZ(LDKC2Tuple_PaymentHashPaymentIdZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_PaymentHashPaymentIdZ)); }
-	operator LDKC2Tuple_PaymentHashPaymentIdZ() && { LDKC2Tuple_PaymentHashPaymentIdZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_PaymentHashPaymentIdZ)); return res; }
-	~C2Tuple_PaymentHashPaymentIdZ() { C2Tuple_PaymentHashPaymentIdZ_free(self); }
-	C2Tuple_PaymentHashPaymentIdZ& operator=(C2Tuple_PaymentHashPaymentIdZ&& o) { C2Tuple_PaymentHashPaymentIdZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_PaymentHashPaymentIdZ)); return *this; }
-	LDKC2Tuple_PaymentHashPaymentIdZ* operator &() { return &self; }
-	LDKC2Tuple_PaymentHashPaymentIdZ* operator ->() { return &self; }
-	const LDKC2Tuple_PaymentHashPaymentIdZ* operator &() const { return &self; }
-	const LDKC2Tuple_PaymentHashPaymentIdZ* operator ->() const { return &self; }
-};
-class CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ {
-private:
-	LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ self;
-public:
-	CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ(const CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ&) = delete;
-	CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ(CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ)); }
-	CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ)); }
-	operator LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ() && { LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ)); return res; }
-	~CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ() { CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(self); }
-	CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ& operator=(CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ&& o) { CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ)); return *this; }
-	LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* operator &() { return &self; }
-	LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* operator ->() { return &self; }
-	const LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* operator &() const { return &self; }
-	const LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* operator ->() const { return &self; }
-};
-class CResult_NoneErrorZ {
+class CVec_SignatureZ {
 private:
-	LDKCResult_NoneErrorZ self;
+	LDKCVec_SignatureZ self;
 public:
-	CResult_NoneErrorZ(const CResult_NoneErrorZ&) = delete;
-	CResult_NoneErrorZ(CResult_NoneErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneErrorZ)); }
-	CResult_NoneErrorZ(LDKCResult_NoneErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneErrorZ)); }
-	operator LDKCResult_NoneErrorZ() && { LDKCResult_NoneErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneErrorZ)); return res; }
-	~CResult_NoneErrorZ() { CResult_NoneErrorZ_free(self); }
-	CResult_NoneErrorZ& operator=(CResult_NoneErrorZ&& o) { CResult_NoneErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneErrorZ)); return *this; }
-	LDKCResult_NoneErrorZ* operator &() { return &self; }
-	LDKCResult_NoneErrorZ* operator ->() { return &self; }
-	const LDKCResult_NoneErrorZ* operator &() const { return &self; }
-	const LDKCResult_NoneErrorZ* operator ->() const { return &self; }
+	CVec_SignatureZ(const CVec_SignatureZ&) = delete;
+	CVec_SignatureZ(CVec_SignatureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_SignatureZ)); }
+	CVec_SignatureZ(LDKCVec_SignatureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_SignatureZ)); }
+	operator LDKCVec_SignatureZ() && { LDKCVec_SignatureZ res = self; memset(&self, 0, sizeof(LDKCVec_SignatureZ)); return res; }
+	~CVec_SignatureZ() { CVec_SignatureZ_free(self); }
+	CVec_SignatureZ& operator=(CVec_SignatureZ&& o) { CVec_SignatureZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_SignatureZ)); return *this; }
+	LDKCVec_SignatureZ* operator &() { return &self; }
+	LDKCVec_SignatureZ* operator ->() { return &self; }
+	const LDKCVec_SignatureZ* operator &() const { return &self; }
+	const LDKCVec_SignatureZ* operator ->() const { return &self; }
+};
+class CVec_u64Z {
+private:
+	LDKCVec_u64Z self;
+public:
+	CVec_u64Z(const CVec_u64Z&) = delete;
+	CVec_u64Z(CVec_u64Z&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_u64Z)); }
+	CVec_u64Z(LDKCVec_u64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_u64Z)); }
+	operator LDKCVec_u64Z() && { LDKCVec_u64Z res = self; memset(&self, 0, sizeof(LDKCVec_u64Z)); return res; }
+	~CVec_u64Z() { CVec_u64Z_free(self); }
+	CVec_u64Z& operator=(CVec_u64Z&& o) { CVec_u64Z_free(self); self = o.self; memset(&o, 0, sizeof(CVec_u64Z)); return *this; }
+	LDKCVec_u64Z* operator &() { return &self; }
+	LDKCVec_u64Z* operator ->() { return &self; }
+	const LDKCVec_u64Z* operator &() const { return &self; }
+	const LDKCVec_u64Z* operator ->() const { return &self; }
 };
 class CResult_StringErrorZ {
 private:
@@ -5843,283 +7536,73 @@ public:
 	COption_EventZ(const COption_EventZ&) = delete;
 	COption_EventZ(COption_EventZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_EventZ)); }
 	COption_EventZ(LDKCOption_EventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_EventZ)); }
-	operator LDKCOption_EventZ() && { LDKCOption_EventZ res = self; memset(&self, 0, sizeof(LDKCOption_EventZ)); return res; }
-	~COption_EventZ() { COption_EventZ_free(self); }
-	COption_EventZ& operator=(COption_EventZ&& o) { COption_EventZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_EventZ)); return *this; }
-	LDKCOption_EventZ* operator &() { return &self; }
-	LDKCOption_EventZ* operator ->() { return &self; }
-	const LDKCOption_EventZ* operator &() const { return &self; }
-	const LDKCOption_EventZ* operator ->() const { return &self; }
-};
-class CResult_ChannelTypeFeaturesDecodeErrorZ {
-private:
-	LDKCResult_ChannelTypeFeaturesDecodeErrorZ self;
-public:
-	CResult_ChannelTypeFeaturesDecodeErrorZ(const CResult_ChannelTypeFeaturesDecodeErrorZ&) = delete;
-	CResult_ChannelTypeFeaturesDecodeErrorZ(CResult_ChannelTypeFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelTypeFeaturesDecodeErrorZ)); }
-	CResult_ChannelTypeFeaturesDecodeErrorZ(LDKCResult_ChannelTypeFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelTypeFeaturesDecodeErrorZ)); }
-	operator LDKCResult_ChannelTypeFeaturesDecodeErrorZ() && { LDKCResult_ChannelTypeFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelTypeFeaturesDecodeErrorZ)); return res; }
-	~CResult_ChannelTypeFeaturesDecodeErrorZ() { CResult_ChannelTypeFeaturesDecodeErrorZ_free(self); }
-	CResult_ChannelTypeFeaturesDecodeErrorZ& operator=(CResult_ChannelTypeFeaturesDecodeErrorZ&& o) { CResult_ChannelTypeFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelTypeFeaturesDecodeErrorZ)); return *this; }
-	LDKCResult_ChannelTypeFeaturesDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_ChannelTypeFeaturesDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_ChannelTypeFeaturesDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_ChannelTypeFeaturesDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_SiPrefixParseErrorZ {
-private:
-	LDKCResult_SiPrefixParseErrorZ self;
-public:
-	CResult_SiPrefixParseErrorZ(const CResult_SiPrefixParseErrorZ&) = delete;
-	CResult_SiPrefixParseErrorZ(CResult_SiPrefixParseErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SiPrefixParseErrorZ)); }
-	CResult_SiPrefixParseErrorZ(LDKCResult_SiPrefixParseErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SiPrefixParseErrorZ)); }
-	operator LDKCResult_SiPrefixParseErrorZ() && { LDKCResult_SiPrefixParseErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SiPrefixParseErrorZ)); return res; }
-	~CResult_SiPrefixParseErrorZ() { CResult_SiPrefixParseErrorZ_free(self); }
-	CResult_SiPrefixParseErrorZ& operator=(CResult_SiPrefixParseErrorZ&& o) { CResult_SiPrefixParseErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SiPrefixParseErrorZ)); return *this; }
-	LDKCResult_SiPrefixParseErrorZ* operator &() { return &self; }
-	LDKCResult_SiPrefixParseErrorZ* operator ->() { return &self; }
-	const LDKCResult_SiPrefixParseErrorZ* operator &() const { return &self; }
-	const LDKCResult_SiPrefixParseErrorZ* operator ->() const { return &self; }
-};
-class CVec_RouteHintZ {
-private:
-	LDKCVec_RouteHintZ self;
-public:
-	CVec_RouteHintZ(const CVec_RouteHintZ&) = delete;
-	CVec_RouteHintZ(CVec_RouteHintZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RouteHintZ)); }
-	CVec_RouteHintZ(LDKCVec_RouteHintZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RouteHintZ)); }
-	operator LDKCVec_RouteHintZ() && { LDKCVec_RouteHintZ res = self; memset(&self, 0, sizeof(LDKCVec_RouteHintZ)); return res; }
-	~CVec_RouteHintZ() { CVec_RouteHintZ_free(self); }
-	CVec_RouteHintZ& operator=(CVec_RouteHintZ&& o) { CVec_RouteHintZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_RouteHintZ)); return *this; }
-	LDKCVec_RouteHintZ* operator &() { return &self; }
-	LDKCVec_RouteHintZ* operator ->() { return &self; }
-	const LDKCVec_RouteHintZ* operator &() const { return &self; }
-	const LDKCVec_RouteHintZ* operator ->() const { return &self; }
-};
-class COption_u16Z {
-private:
-	LDKCOption_u16Z self;
-public:
-	COption_u16Z(const COption_u16Z&) = delete;
-	COption_u16Z(COption_u16Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_u16Z)); }
-	COption_u16Z(LDKCOption_u16Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_u16Z)); }
-	operator LDKCOption_u16Z() && { LDKCOption_u16Z res = self; memset(&self, 0, sizeof(LDKCOption_u16Z)); return res; }
-	~COption_u16Z() { COption_u16Z_free(self); }
-	COption_u16Z& operator=(COption_u16Z&& o) { COption_u16Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_u16Z)); return *this; }
-	LDKCOption_u16Z* operator &() { return &self; }
-	LDKCOption_u16Z* operator ->() { return &self; }
-	const LDKCOption_u16Z* operator &() const { return &self; }
-	const LDKCOption_u16Z* operator ->() const { return &self; }
-};
-class CVec_CVec_RouteHopZZ {
-private:
-	LDKCVec_CVec_RouteHopZZ self;
-public:
-	CVec_CVec_RouteHopZZ(const CVec_CVec_RouteHopZZ&) = delete;
-	CVec_CVec_RouteHopZZ(CVec_CVec_RouteHopZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_CVec_RouteHopZZ)); }
-	CVec_CVec_RouteHopZZ(LDKCVec_CVec_RouteHopZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_CVec_RouteHopZZ)); }
-	operator LDKCVec_CVec_RouteHopZZ() && { LDKCVec_CVec_RouteHopZZ res = self; memset(&self, 0, sizeof(LDKCVec_CVec_RouteHopZZ)); return res; }
-	~CVec_CVec_RouteHopZZ() { CVec_CVec_RouteHopZZ_free(self); }
-	CVec_CVec_RouteHopZZ& operator=(CVec_CVec_RouteHopZZ&& o) { CVec_CVec_RouteHopZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_CVec_RouteHopZZ)); return *this; }
-	LDKCVec_CVec_RouteHopZZ* operator &() { return &self; }
-	LDKCVec_CVec_RouteHopZZ* operator ->() { return &self; }
-	const LDKCVec_CVec_RouteHopZZ* operator &() const { return &self; }
-	const LDKCVec_CVec_RouteHopZZ* operator ->() const { return &self; }
-};
-class CResult_TrustedCommitmentTransactionNoneZ {
-private:
-	LDKCResult_TrustedCommitmentTransactionNoneZ self;
-public:
-	CResult_TrustedCommitmentTransactionNoneZ(const CResult_TrustedCommitmentTransactionNoneZ&) = delete;
-	CResult_TrustedCommitmentTransactionNoneZ(CResult_TrustedCommitmentTransactionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TrustedCommitmentTransactionNoneZ)); }
-	CResult_TrustedCommitmentTransactionNoneZ(LDKCResult_TrustedCommitmentTransactionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ)); }
-	operator LDKCResult_TrustedCommitmentTransactionNoneZ() && { LDKCResult_TrustedCommitmentTransactionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ)); return res; }
-	~CResult_TrustedCommitmentTransactionNoneZ() { CResult_TrustedCommitmentTransactionNoneZ_free(self); }
-	CResult_TrustedCommitmentTransactionNoneZ& operator=(CResult_TrustedCommitmentTransactionNoneZ&& o) { CResult_TrustedCommitmentTransactionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TrustedCommitmentTransactionNoneZ)); return *this; }
-	LDKCResult_TrustedCommitmentTransactionNoneZ* operator &() { return &self; }
-	LDKCResult_TrustedCommitmentTransactionNoneZ* operator ->() { return &self; }
-	const LDKCResult_TrustedCommitmentTransactionNoneZ* operator &() const { return &self; }
-	const LDKCResult_TrustedCommitmentTransactionNoneZ* operator ->() const { return &self; }
-};
-class CResult_FixedPenaltyScorerDecodeErrorZ {
-private:
-	LDKCResult_FixedPenaltyScorerDecodeErrorZ self;
-public:
-	CResult_FixedPenaltyScorerDecodeErrorZ(const CResult_FixedPenaltyScorerDecodeErrorZ&) = delete;
-	CResult_FixedPenaltyScorerDecodeErrorZ(CResult_FixedPenaltyScorerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FixedPenaltyScorerDecodeErrorZ)); }
-	CResult_FixedPenaltyScorerDecodeErrorZ(LDKCResult_FixedPenaltyScorerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ)); }
-	operator LDKCResult_FixedPenaltyScorerDecodeErrorZ() && { LDKCResult_FixedPenaltyScorerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ)); return res; }
-	~CResult_FixedPenaltyScorerDecodeErrorZ() { CResult_FixedPenaltyScorerDecodeErrorZ_free(self); }
-	CResult_FixedPenaltyScorerDecodeErrorZ& operator=(CResult_FixedPenaltyScorerDecodeErrorZ&& o) { CResult_FixedPenaltyScorerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FixedPenaltyScorerDecodeErrorZ)); return *this; }
-	LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_NoneLightningErrorZ {
-private:
-	LDKCResult_NoneLightningErrorZ self;
-public:
-	CResult_NoneLightningErrorZ(const CResult_NoneLightningErrorZ&) = delete;
-	CResult_NoneLightningErrorZ(CResult_NoneLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneLightningErrorZ)); }
-	CResult_NoneLightningErrorZ(LDKCResult_NoneLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneLightningErrorZ)); }
-	operator LDKCResult_NoneLightningErrorZ() && { LDKCResult_NoneLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneLightningErrorZ)); return res; }
-	~CResult_NoneLightningErrorZ() { CResult_NoneLightningErrorZ_free(self); }
-	CResult_NoneLightningErrorZ& operator=(CResult_NoneLightningErrorZ&& o) { CResult_NoneLightningErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneLightningErrorZ)); return *this; }
-	LDKCResult_NoneLightningErrorZ* operator &() { return &self; }
-	LDKCResult_NoneLightningErrorZ* operator ->() { return &self; }
-	const LDKCResult_NoneLightningErrorZ* operator &() const { return &self; }
-	const LDKCResult_NoneLightningErrorZ* operator ->() const { return &self; }
-};
-class CResult_NonePeerHandleErrorZ {
-private:
-	LDKCResult_NonePeerHandleErrorZ self;
-public:
-	CResult_NonePeerHandleErrorZ(const CResult_NonePeerHandleErrorZ&) = delete;
-	CResult_NonePeerHandleErrorZ(CResult_NonePeerHandleErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NonePeerHandleErrorZ)); }
-	CResult_NonePeerHandleErrorZ(LDKCResult_NonePeerHandleErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NonePeerHandleErrorZ)); }
-	operator LDKCResult_NonePeerHandleErrorZ() && { LDKCResult_NonePeerHandleErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NonePeerHandleErrorZ)); return res; }
-	~CResult_NonePeerHandleErrorZ() { CResult_NonePeerHandleErrorZ_free(self); }
-	CResult_NonePeerHandleErrorZ& operator=(CResult_NonePeerHandleErrorZ&& o) { CResult_NonePeerHandleErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NonePeerHandleErrorZ)); return *this; }
-	LDKCResult_NonePeerHandleErrorZ* operator &() { return &self; }
-	LDKCResult_NonePeerHandleErrorZ* operator ->() { return &self; }
-	const LDKCResult_NonePeerHandleErrorZ* operator &() const { return &self; }
-	const LDKCResult_NonePeerHandleErrorZ* operator ->() const { return &self; }
-};
-class CResult_COption_EventZDecodeErrorZ {
-private:
-	LDKCResult_COption_EventZDecodeErrorZ self;
-public:
-	CResult_COption_EventZDecodeErrorZ(const CResult_COption_EventZDecodeErrorZ&) = delete;
-	CResult_COption_EventZDecodeErrorZ(CResult_COption_EventZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_EventZDecodeErrorZ)); }
-	CResult_COption_EventZDecodeErrorZ(LDKCResult_COption_EventZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_EventZDecodeErrorZ)); }
-	operator LDKCResult_COption_EventZDecodeErrorZ() && { LDKCResult_COption_EventZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_EventZDecodeErrorZ)); return res; }
-	~CResult_COption_EventZDecodeErrorZ() { CResult_COption_EventZDecodeErrorZ_free(self); }
-	CResult_COption_EventZDecodeErrorZ& operator=(CResult_COption_EventZDecodeErrorZ&& o) { CResult_COption_EventZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_EventZDecodeErrorZ)); return *this; }
-	LDKCResult_COption_EventZDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_COption_EventZDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_COption_EventZDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_COption_EventZDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_CVec_SignatureZNoneZ {
-private:
-	LDKCResult_CVec_SignatureZNoneZ self;
-public:
-	CResult_CVec_SignatureZNoneZ(const CResult_CVec_SignatureZNoneZ&) = delete;
-	CResult_CVec_SignatureZNoneZ(CResult_CVec_SignatureZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_SignatureZNoneZ)); }
-	CResult_CVec_SignatureZNoneZ(LDKCResult_CVec_SignatureZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_SignatureZNoneZ)); }
-	operator LDKCResult_CVec_SignatureZNoneZ() && { LDKCResult_CVec_SignatureZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_SignatureZNoneZ)); return res; }
-	~CResult_CVec_SignatureZNoneZ() { CResult_CVec_SignatureZNoneZ_free(self); }
-	CResult_CVec_SignatureZNoneZ& operator=(CResult_CVec_SignatureZNoneZ&& o) { CResult_CVec_SignatureZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_SignatureZNoneZ)); return *this; }
-	LDKCResult_CVec_SignatureZNoneZ* operator &() { return &self; }
-	LDKCResult_CVec_SignatureZNoneZ* operator ->() { return &self; }
-	const LDKCResult_CVec_SignatureZNoneZ* operator &() const { return &self; }
-	const LDKCResult_CVec_SignatureZNoneZ* operator ->() const { return &self; }
-};
-class COption_CVec_NetAddressZZ {
-private:
-	LDKCOption_CVec_NetAddressZZ self;
-public:
-	COption_CVec_NetAddressZZ(const COption_CVec_NetAddressZZ&) = delete;
-	COption_CVec_NetAddressZZ(COption_CVec_NetAddressZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_CVec_NetAddressZZ)); }
-	COption_CVec_NetAddressZZ(LDKCOption_CVec_NetAddressZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_CVec_NetAddressZZ)); }
-	operator LDKCOption_CVec_NetAddressZZ() && { LDKCOption_CVec_NetAddressZZ res = self; memset(&self, 0, sizeof(LDKCOption_CVec_NetAddressZZ)); return res; }
-	~COption_CVec_NetAddressZZ() { COption_CVec_NetAddressZZ_free(self); }
-	COption_CVec_NetAddressZZ& operator=(COption_CVec_NetAddressZZ&& o) { COption_CVec_NetAddressZZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_CVec_NetAddressZZ)); return *this; }
-	LDKCOption_CVec_NetAddressZZ* operator &() { return &self; }
-	LDKCOption_CVec_NetAddressZZ* operator ->() { return &self; }
-	const LDKCOption_CVec_NetAddressZZ* operator &() const { return &self; }
-	const LDKCOption_CVec_NetAddressZZ* operator ->() const { return &self; }
-};
-class CResult__u832APIErrorZ {
-private:
-	LDKCResult__u832APIErrorZ self;
-public:
-	CResult__u832APIErrorZ(const CResult__u832APIErrorZ&) = delete;
-	CResult__u832APIErrorZ(CResult__u832APIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult__u832APIErrorZ)); }
-	CResult__u832APIErrorZ(LDKCResult__u832APIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult__u832APIErrorZ)); }
-	operator LDKCResult__u832APIErrorZ() && { LDKCResult__u832APIErrorZ res = self; memset(&self, 0, sizeof(LDKCResult__u832APIErrorZ)); return res; }
-	~CResult__u832APIErrorZ() { CResult__u832APIErrorZ_free(self); }
-	CResult__u832APIErrorZ& operator=(CResult__u832APIErrorZ&& o) { CResult__u832APIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult__u832APIErrorZ)); return *this; }
-	LDKCResult__u832APIErrorZ* operator &() { return &self; }
-	LDKCResult__u832APIErrorZ* operator ->() { return &self; }
-	const LDKCResult__u832APIErrorZ* operator &() const { return &self; }
-	const LDKCResult__u832APIErrorZ* operator ->() const { return &self; }
-};
-class CResult_PaymentIdPaymentErrorZ {
-private:
-	LDKCResult_PaymentIdPaymentErrorZ self;
-public:
-	CResult_PaymentIdPaymentErrorZ(const CResult_PaymentIdPaymentErrorZ&) = delete;
-	CResult_PaymentIdPaymentErrorZ(CResult_PaymentIdPaymentErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentIdPaymentErrorZ)); }
-	CResult_PaymentIdPaymentErrorZ(LDKCResult_PaymentIdPaymentErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentIdPaymentErrorZ)); }
-	operator LDKCResult_PaymentIdPaymentErrorZ() && { LDKCResult_PaymentIdPaymentErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentIdPaymentErrorZ)); return res; }
-	~CResult_PaymentIdPaymentErrorZ() { CResult_PaymentIdPaymentErrorZ_free(self); }
-	CResult_PaymentIdPaymentErrorZ& operator=(CResult_PaymentIdPaymentErrorZ&& o) { CResult_PaymentIdPaymentErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentIdPaymentErrorZ)); return *this; }
-	LDKCResult_PaymentIdPaymentErrorZ* operator &() { return &self; }
-	LDKCResult_PaymentIdPaymentErrorZ* operator ->() { return &self; }
-	const LDKCResult_PaymentIdPaymentErrorZ* operator &() const { return &self; }
-	const LDKCResult_PaymentIdPaymentErrorZ* operator ->() const { return &self; }
+	operator LDKCOption_EventZ() && { LDKCOption_EventZ res = self; memset(&self, 0, sizeof(LDKCOption_EventZ)); return res; }
+	~COption_EventZ() { COption_EventZ_free(self); }
+	COption_EventZ& operator=(COption_EventZ&& o) { COption_EventZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_EventZ)); return *this; }
+	LDKCOption_EventZ* operator &() { return &self; }
+	LDKCOption_EventZ* operator ->() { return &self; }
+	const LDKCOption_EventZ* operator &() const { return &self; }
+	const LDKCOption_EventZ* operator ->() const { return &self; }
 };
-class CResult_DescriptionCreationErrorZ {
+class CResult_ChannelTypeFeaturesDecodeErrorZ {
 private:
-	LDKCResult_DescriptionCreationErrorZ self;
+	LDKCResult_ChannelTypeFeaturesDecodeErrorZ self;
 public:
-	CResult_DescriptionCreationErrorZ(const CResult_DescriptionCreationErrorZ&) = delete;
-	CResult_DescriptionCreationErrorZ(CResult_DescriptionCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_DescriptionCreationErrorZ)); }
-	CResult_DescriptionCreationErrorZ(LDKCResult_DescriptionCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_DescriptionCreationErrorZ)); }
-	operator LDKCResult_DescriptionCreationErrorZ() && { LDKCResult_DescriptionCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_DescriptionCreationErrorZ)); return res; }
-	~CResult_DescriptionCreationErrorZ() { CResult_DescriptionCreationErrorZ_free(self); }
-	CResult_DescriptionCreationErrorZ& operator=(CResult_DescriptionCreationErrorZ&& o) { CResult_DescriptionCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_DescriptionCreationErrorZ)); return *this; }
-	LDKCResult_DescriptionCreationErrorZ* operator &() { return &self; }
-	LDKCResult_DescriptionCreationErrorZ* operator ->() { return &self; }
-	const LDKCResult_DescriptionCreationErrorZ* operator &() const { return &self; }
-	const LDKCResult_DescriptionCreationErrorZ* operator ->() const { return &self; }
+	CResult_ChannelTypeFeaturesDecodeErrorZ(const CResult_ChannelTypeFeaturesDecodeErrorZ&) = delete;
+	CResult_ChannelTypeFeaturesDecodeErrorZ(CResult_ChannelTypeFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelTypeFeaturesDecodeErrorZ)); }
+	CResult_ChannelTypeFeaturesDecodeErrorZ(LDKCResult_ChannelTypeFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelTypeFeaturesDecodeErrorZ)); }
+	operator LDKCResult_ChannelTypeFeaturesDecodeErrorZ() && { LDKCResult_ChannelTypeFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelTypeFeaturesDecodeErrorZ)); return res; }
+	~CResult_ChannelTypeFeaturesDecodeErrorZ() { CResult_ChannelTypeFeaturesDecodeErrorZ_free(self); }
+	CResult_ChannelTypeFeaturesDecodeErrorZ& operator=(CResult_ChannelTypeFeaturesDecodeErrorZ&& o) { CResult_ChannelTypeFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelTypeFeaturesDecodeErrorZ)); return *this; }
+	LDKCResult_ChannelTypeFeaturesDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_ChannelTypeFeaturesDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_ChannelTypeFeaturesDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_ChannelTypeFeaturesDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_RoutingFeesDecodeErrorZ {
+class CVec_RouteHintZ {
 private:
-	LDKCResult_RoutingFeesDecodeErrorZ self;
+	LDKCVec_RouteHintZ self;
 public:
-	CResult_RoutingFeesDecodeErrorZ(const CResult_RoutingFeesDecodeErrorZ&) = delete;
-	CResult_RoutingFeesDecodeErrorZ(CResult_RoutingFeesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RoutingFeesDecodeErrorZ)); }
-	CResult_RoutingFeesDecodeErrorZ(LDKCResult_RoutingFeesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RoutingFeesDecodeErrorZ)); }
-	operator LDKCResult_RoutingFeesDecodeErrorZ() && { LDKCResult_RoutingFeesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RoutingFeesDecodeErrorZ)); return res; }
-	~CResult_RoutingFeesDecodeErrorZ() { CResult_RoutingFeesDecodeErrorZ_free(self); }
-	CResult_RoutingFeesDecodeErrorZ& operator=(CResult_RoutingFeesDecodeErrorZ&& o) { CResult_RoutingFeesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RoutingFeesDecodeErrorZ)); return *this; }
-	LDKCResult_RoutingFeesDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_RoutingFeesDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_RoutingFeesDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_RoutingFeesDecodeErrorZ* operator ->() const { return &self; }
+	CVec_RouteHintZ(const CVec_RouteHintZ&) = delete;
+	CVec_RouteHintZ(CVec_RouteHintZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RouteHintZ)); }
+	CVec_RouteHintZ(LDKCVec_RouteHintZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RouteHintZ)); }
+	operator LDKCVec_RouteHintZ() && { LDKCVec_RouteHintZ res = self; memset(&self, 0, sizeof(LDKCVec_RouteHintZ)); return res; }
+	~CVec_RouteHintZ() { CVec_RouteHintZ_free(self); }
+	CVec_RouteHintZ& operator=(CVec_RouteHintZ&& o) { CVec_RouteHintZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_RouteHintZ)); return *this; }
+	LDKCVec_RouteHintZ* operator &() { return &self; }
+	LDKCVec_RouteHintZ* operator ->() { return &self; }
+	const LDKCVec_RouteHintZ* operator &() const { return &self; }
+	const LDKCVec_RouteHintZ* operator ->() const { return &self; }
 };
-class CResult_PayeePubKeyErrorZ {
+class COption_u16Z {
 private:
-	LDKCResult_PayeePubKeyErrorZ self;
+	LDKCOption_u16Z self;
 public:
-	CResult_PayeePubKeyErrorZ(const CResult_PayeePubKeyErrorZ&) = delete;
-	CResult_PayeePubKeyErrorZ(CResult_PayeePubKeyErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PayeePubKeyErrorZ)); }
-	CResult_PayeePubKeyErrorZ(LDKCResult_PayeePubKeyErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PayeePubKeyErrorZ)); }
-	operator LDKCResult_PayeePubKeyErrorZ() && { LDKCResult_PayeePubKeyErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PayeePubKeyErrorZ)); return res; }
-	~CResult_PayeePubKeyErrorZ() { CResult_PayeePubKeyErrorZ_free(self); }
-	CResult_PayeePubKeyErrorZ& operator=(CResult_PayeePubKeyErrorZ&& o) { CResult_PayeePubKeyErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PayeePubKeyErrorZ)); return *this; }
-	LDKCResult_PayeePubKeyErrorZ* operator &() { return &self; }
-	LDKCResult_PayeePubKeyErrorZ* operator ->() { return &self; }
-	const LDKCResult_PayeePubKeyErrorZ* operator &() const { return &self; }
-	const LDKCResult_PayeePubKeyErrorZ* operator ->() const { return &self; }
+	COption_u16Z(const COption_u16Z&) = delete;
+	COption_u16Z(COption_u16Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_u16Z)); }
+	COption_u16Z(LDKCOption_u16Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_u16Z)); }
+	operator LDKCOption_u16Z() && { LDKCOption_u16Z res = self; memset(&self, 0, sizeof(LDKCOption_u16Z)); return res; }
+	~COption_u16Z() { COption_u16Z_free(self); }
+	COption_u16Z& operator=(COption_u16Z&& o) { COption_u16Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_u16Z)); return *this; }
+	LDKCOption_u16Z* operator &() { return &self; }
+	LDKCOption_u16Z* operator ->() { return &self; }
+	const LDKCOption_u16Z* operator &() const { return &self; }
+	const LDKCOption_u16Z* operator ->() const { return &self; }
 };
-class CResult_COption_MonitorEventZDecodeErrorZ {
+class CVec_CVec_RouteHopZZ {
 private:
-	LDKCResult_COption_MonitorEventZDecodeErrorZ self;
+	LDKCVec_CVec_RouteHopZZ self;
 public:
-	CResult_COption_MonitorEventZDecodeErrorZ(const CResult_COption_MonitorEventZDecodeErrorZ&) = delete;
-	CResult_COption_MonitorEventZDecodeErrorZ(CResult_COption_MonitorEventZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_MonitorEventZDecodeErrorZ)); }
-	CResult_COption_MonitorEventZDecodeErrorZ(LDKCResult_COption_MonitorEventZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ)); }
-	operator LDKCResult_COption_MonitorEventZDecodeErrorZ() && { LDKCResult_COption_MonitorEventZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ)); return res; }
-	~CResult_COption_MonitorEventZDecodeErrorZ() { CResult_COption_MonitorEventZDecodeErrorZ_free(self); }
-	CResult_COption_MonitorEventZDecodeErrorZ& operator=(CResult_COption_MonitorEventZDecodeErrorZ&& o) { CResult_COption_MonitorEventZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_MonitorEventZDecodeErrorZ)); return *this; }
-	LDKCResult_COption_MonitorEventZDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_COption_MonitorEventZDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_COption_MonitorEventZDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_COption_MonitorEventZDecodeErrorZ* operator ->() const { return &self; }
+	CVec_CVec_RouteHopZZ(const CVec_CVec_RouteHopZZ&) = delete;
+	CVec_CVec_RouteHopZZ(CVec_CVec_RouteHopZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_CVec_RouteHopZZ)); }
+	CVec_CVec_RouteHopZZ(LDKCVec_CVec_RouteHopZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_CVec_RouteHopZZ)); }
+	operator LDKCVec_CVec_RouteHopZZ() && { LDKCVec_CVec_RouteHopZZ res = self; memset(&self, 0, sizeof(LDKCVec_CVec_RouteHopZZ)); return res; }
+	~CVec_CVec_RouteHopZZ() { CVec_CVec_RouteHopZZ_free(self); }
+	CVec_CVec_RouteHopZZ& operator=(CVec_CVec_RouteHopZZ&& o) { CVec_CVec_RouteHopZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_CVec_RouteHopZZ)); return *this; }
+	LDKCVec_CVec_RouteHopZZ* operator &() { return &self; }
+	LDKCVec_CVec_RouteHopZZ* operator ->() { return &self; }
+	const LDKCVec_CVec_RouteHopZZ* operator &() const { return &self; }
+	const LDKCVec_CVec_RouteHopZZ* operator ->() const { return &self; }
 };
 class CVec_C2Tuple_PublicKeyTypeZZ {
 private:
@@ -6136,6 +7619,21 @@ public:
 	const LDKCVec_C2Tuple_PublicKeyTypeZZ* operator &() const { return &self; }
 	const LDKCVec_C2Tuple_PublicKeyTypeZZ* 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 CResult_u32GraphSyncErrorZ {
 private:
 	LDKCResult_u32GraphSyncErrorZ self;
@@ -6151,50 +7649,35 @@ public:
 	const LDKCResult_u32GraphSyncErrorZ* operator &() const { return &self; }
 	const LDKCResult_u32GraphSyncErrorZ* operator ->() const { return &self; }
 };
-class CResult_InvoiceSemanticErrorZ {
-private:
-	LDKCResult_InvoiceSemanticErrorZ self;
-public:
-	CResult_InvoiceSemanticErrorZ(const CResult_InvoiceSemanticErrorZ&) = delete;
-	CResult_InvoiceSemanticErrorZ(CResult_InvoiceSemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceSemanticErrorZ)); }
-	CResult_InvoiceSemanticErrorZ(LDKCResult_InvoiceSemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceSemanticErrorZ)); }
-	operator LDKCResult_InvoiceSemanticErrorZ() && { LDKCResult_InvoiceSemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceSemanticErrorZ)); return res; }
-	~CResult_InvoiceSemanticErrorZ() { CResult_InvoiceSemanticErrorZ_free(self); }
-	CResult_InvoiceSemanticErrorZ& operator=(CResult_InvoiceSemanticErrorZ&& o) { CResult_InvoiceSemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceSemanticErrorZ)); return *this; }
-	LDKCResult_InvoiceSemanticErrorZ* operator &() { return &self; }
-	LDKCResult_InvoiceSemanticErrorZ* operator ->() { return &self; }
-	const LDKCResult_InvoiceSemanticErrorZ* operator &() const { return &self; }
-	const LDKCResult_InvoiceSemanticErrorZ* operator ->() const { return &self; }
-};
-class CResult_UpdateAddHTLCDecodeErrorZ {
+class CVec_PhantomRouteHintsZ {
 private:
-	LDKCResult_UpdateAddHTLCDecodeErrorZ self;
+	LDKCVec_PhantomRouteHintsZ self;
 public:
-	CResult_UpdateAddHTLCDecodeErrorZ(const CResult_UpdateAddHTLCDecodeErrorZ&) = delete;
-	CResult_UpdateAddHTLCDecodeErrorZ(CResult_UpdateAddHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateAddHTLCDecodeErrorZ)); }
-	CResult_UpdateAddHTLCDecodeErrorZ(LDKCResult_UpdateAddHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ)); }
-	operator LDKCResult_UpdateAddHTLCDecodeErrorZ() && { LDKCResult_UpdateAddHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ)); return res; }
-	~CResult_UpdateAddHTLCDecodeErrorZ() { CResult_UpdateAddHTLCDecodeErrorZ_free(self); }
-	CResult_UpdateAddHTLCDecodeErrorZ& operator=(CResult_UpdateAddHTLCDecodeErrorZ&& o) { CResult_UpdateAddHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateAddHTLCDecodeErrorZ)); return *this; }
-	LDKCResult_UpdateAddHTLCDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_UpdateAddHTLCDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_UpdateAddHTLCDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_UpdateAddHTLCDecodeErrorZ* operator ->() const { return &self; }
+	CVec_PhantomRouteHintsZ(const CVec_PhantomRouteHintsZ&) = delete;
+	CVec_PhantomRouteHintsZ(CVec_PhantomRouteHintsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PhantomRouteHintsZ)); }
+	CVec_PhantomRouteHintsZ(LDKCVec_PhantomRouteHintsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PhantomRouteHintsZ)); }
+	operator LDKCVec_PhantomRouteHintsZ() && { LDKCVec_PhantomRouteHintsZ res = self; memset(&self, 0, sizeof(LDKCVec_PhantomRouteHintsZ)); return res; }
+	~CVec_PhantomRouteHintsZ() { CVec_PhantomRouteHintsZ_free(self); }
+	CVec_PhantomRouteHintsZ& operator=(CVec_PhantomRouteHintsZ&& o) { CVec_PhantomRouteHintsZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PhantomRouteHintsZ)); return *this; }
+	LDKCVec_PhantomRouteHintsZ* operator &() { return &self; }
+	LDKCVec_PhantomRouteHintsZ* operator ->() { return &self; }
+	const LDKCVec_PhantomRouteHintsZ* operator &() const { return &self; }
+	const LDKCVec_PhantomRouteHintsZ* operator ->() const { return &self; }
 };
-class CResult_QueryShortChannelIdsDecodeErrorZ {
+class CResult_NoneAPIErrorZ {
 private:
-	LDKCResult_QueryShortChannelIdsDecodeErrorZ self;
+	LDKCResult_NoneAPIErrorZ 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; }
+	CResult_NoneAPIErrorZ(const CResult_NoneAPIErrorZ&) = delete;
+	CResult_NoneAPIErrorZ(CResult_NoneAPIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneAPIErrorZ)); }
+	CResult_NoneAPIErrorZ(LDKCResult_NoneAPIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneAPIErrorZ)); }
+	operator LDKCResult_NoneAPIErrorZ() && { LDKCResult_NoneAPIErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneAPIErrorZ)); return res; }
+	~CResult_NoneAPIErrorZ() { CResult_NoneAPIErrorZ_free(self); }
+	CResult_NoneAPIErrorZ& operator=(CResult_NoneAPIErrorZ&& o) { CResult_NoneAPIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneAPIErrorZ)); return *this; }
+	LDKCResult_NoneAPIErrorZ* operator &() { return &self; }
+	LDKCResult_NoneAPIErrorZ* operator ->() { return &self; }
+	const LDKCResult_NoneAPIErrorZ* operator &() const { return &self; }
+	const LDKCResult_NoneAPIErrorZ* operator ->() const { return &self; }
 };
 class CResult_CounterpartyChannelTransactionParametersDecodeErrorZ {
 private:
@@ -6211,21 +7694,6 @@ public:
 	const LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_NoneAPIErrorZ {
-private:
-	LDKCResult_NoneAPIErrorZ self;
-public:
-	CResult_NoneAPIErrorZ(const CResult_NoneAPIErrorZ&) = delete;
-	CResult_NoneAPIErrorZ(CResult_NoneAPIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneAPIErrorZ)); }
-	CResult_NoneAPIErrorZ(LDKCResult_NoneAPIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneAPIErrorZ)); }
-	operator LDKCResult_NoneAPIErrorZ() && { LDKCResult_NoneAPIErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneAPIErrorZ)); return res; }
-	~CResult_NoneAPIErrorZ() { CResult_NoneAPIErrorZ_free(self); }
-	CResult_NoneAPIErrorZ& operator=(CResult_NoneAPIErrorZ&& o) { CResult_NoneAPIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneAPIErrorZ)); return *this; }
-	LDKCResult_NoneAPIErrorZ* operator &() { return &self; }
-	LDKCResult_NoneAPIErrorZ* operator ->() { return &self; }
-	const LDKCResult_NoneAPIErrorZ* operator &() const { return &self; }
-	const LDKCResult_NoneAPIErrorZ* operator ->() const { return &self; }
-};
 class CVec_NetAddressZ {
 private:
 	LDKCVec_NetAddressZ self;
@@ -6286,80 +7754,20 @@ public:
 	const LDKCVec_C2Tuple_usizeTransactionZZ* operator &() const { return &self; }
 	const LDKCVec_C2Tuple_usizeTransactionZZ* operator ->() const { return &self; }
 };
-class CVec_PhantomRouteHintsZ {
-private:
-	LDKCVec_PhantomRouteHintsZ self;
-public:
-	CVec_PhantomRouteHintsZ(const CVec_PhantomRouteHintsZ&) = delete;
-	CVec_PhantomRouteHintsZ(CVec_PhantomRouteHintsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PhantomRouteHintsZ)); }
-	CVec_PhantomRouteHintsZ(LDKCVec_PhantomRouteHintsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PhantomRouteHintsZ)); }
-	operator LDKCVec_PhantomRouteHintsZ() && { LDKCVec_PhantomRouteHintsZ res = self; memset(&self, 0, sizeof(LDKCVec_PhantomRouteHintsZ)); return res; }
-	~CVec_PhantomRouteHintsZ() { CVec_PhantomRouteHintsZ_free(self); }
-	CVec_PhantomRouteHintsZ& operator=(CVec_PhantomRouteHintsZ&& o) { CVec_PhantomRouteHintsZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PhantomRouteHintsZ)); return *this; }
-	LDKCVec_PhantomRouteHintsZ* operator &() { return &self; }
-	LDKCVec_PhantomRouteHintsZ* operator ->() { return &self; }
-	const LDKCVec_PhantomRouteHintsZ* operator &() const { return &self; }
-	const LDKCVec_PhantomRouteHintsZ* operator ->() const { return &self; }
-};
-class COption_MonitorEventZ {
-private:
-	LDKCOption_MonitorEventZ self;
-public:
-	COption_MonitorEventZ(const COption_MonitorEventZ&) = delete;
-	COption_MonitorEventZ(COption_MonitorEventZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_MonitorEventZ)); }
-	COption_MonitorEventZ(LDKCOption_MonitorEventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_MonitorEventZ)); }
-	operator LDKCOption_MonitorEventZ() && { LDKCOption_MonitorEventZ res = self; memset(&self, 0, sizeof(LDKCOption_MonitorEventZ)); return res; }
-	~COption_MonitorEventZ() { COption_MonitorEventZ_free(self); }
-	COption_MonitorEventZ& operator=(COption_MonitorEventZ&& o) { COption_MonitorEventZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_MonitorEventZ)); return *this; }
-	LDKCOption_MonitorEventZ* operator &() { return &self; }
-	LDKCOption_MonitorEventZ* operator ->() { return &self; }
-	const LDKCOption_MonitorEventZ* operator &() const { return &self; }
-	const LDKCOption_MonitorEventZ* operator ->() const { return &self; }
-};
 class C2Tuple_u64u64Z {
 private:
-	LDKC2Tuple_u64u64Z self;
-public:
-	C2Tuple_u64u64Z(const C2Tuple_u64u64Z&) = delete;
-	C2Tuple_u64u64Z(C2Tuple_u64u64Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_u64u64Z)); }
-	C2Tuple_u64u64Z(LDKC2Tuple_u64u64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_u64u64Z)); }
-	operator LDKC2Tuple_u64u64Z() && { LDKC2Tuple_u64u64Z res = self; memset(&self, 0, sizeof(LDKC2Tuple_u64u64Z)); return res; }
-	~C2Tuple_u64u64Z() { C2Tuple_u64u64Z_free(self); }
-	C2Tuple_u64u64Z& operator=(C2Tuple_u64u64Z&& o) { C2Tuple_u64u64Z_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_u64u64Z)); return *this; }
-	LDKC2Tuple_u64u64Z* operator &() { return &self; }
-	LDKC2Tuple_u64u64Z* operator ->() { return &self; }
-	const LDKC2Tuple_u64u64Z* operator &() const { return &self; }
-	const LDKC2Tuple_u64u64Z* operator ->() const { return &self; }
-};
-class COption_TypeZ {
-private:
-	LDKCOption_TypeZ self;
-public:
-	COption_TypeZ(const COption_TypeZ&) = delete;
-	COption_TypeZ(COption_TypeZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_TypeZ)); }
-	COption_TypeZ(LDKCOption_TypeZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_TypeZ)); }
-	operator LDKCOption_TypeZ() && { LDKCOption_TypeZ res = self; memset(&self, 0, sizeof(LDKCOption_TypeZ)); return res; }
-	~COption_TypeZ() { COption_TypeZ_free(self); }
-	COption_TypeZ& operator=(COption_TypeZ&& o) { COption_TypeZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_TypeZ)); return *this; }
-	LDKCOption_TypeZ* operator &() { return &self; }
-	LDKCOption_TypeZ* operator ->() { return &self; }
-	const LDKCOption_TypeZ* operator &() const { return &self; }
-	const LDKCOption_TypeZ* operator ->() const { return &self; }
-};
-class CResult_COption_TypeZDecodeErrorZ {
-private:
-	LDKCResult_COption_TypeZDecodeErrorZ self;
-public:
-	CResult_COption_TypeZDecodeErrorZ(const CResult_COption_TypeZDecodeErrorZ&) = delete;
-	CResult_COption_TypeZDecodeErrorZ(CResult_COption_TypeZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_TypeZDecodeErrorZ)); }
-	CResult_COption_TypeZDecodeErrorZ(LDKCResult_COption_TypeZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_TypeZDecodeErrorZ)); }
-	operator LDKCResult_COption_TypeZDecodeErrorZ() && { LDKCResult_COption_TypeZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_TypeZDecodeErrorZ)); return res; }
-	~CResult_COption_TypeZDecodeErrorZ() { CResult_COption_TypeZDecodeErrorZ_free(self); }
-	CResult_COption_TypeZDecodeErrorZ& operator=(CResult_COption_TypeZDecodeErrorZ&& o) { CResult_COption_TypeZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_TypeZDecodeErrorZ)); return *this; }
-	LDKCResult_COption_TypeZDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_COption_TypeZDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_COption_TypeZDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_COption_TypeZDecodeErrorZ* operator ->() const { return &self; }
+	LDKC2Tuple_u64u64Z self;
+public:
+	C2Tuple_u64u64Z(const C2Tuple_u64u64Z&) = delete;
+	C2Tuple_u64u64Z(C2Tuple_u64u64Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_u64u64Z)); }
+	C2Tuple_u64u64Z(LDKC2Tuple_u64u64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_u64u64Z)); }
+	operator LDKC2Tuple_u64u64Z() && { LDKC2Tuple_u64u64Z res = self; memset(&self, 0, sizeof(LDKC2Tuple_u64u64Z)); return res; }
+	~C2Tuple_u64u64Z() { C2Tuple_u64u64Z_free(self); }
+	C2Tuple_u64u64Z& operator=(C2Tuple_u64u64Z&& o) { C2Tuple_u64u64Z_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_u64u64Z)); return *this; }
+	LDKC2Tuple_u64u64Z* operator &() { return &self; }
+	LDKC2Tuple_u64u64Z* operator ->() { return &self; }
+	const LDKC2Tuple_u64u64Z* operator &() const { return &self; }
+	const LDKC2Tuple_u64u64Z* operator ->() const { return &self; }
 };
 class C2Tuple_u32TxOutZ {
 private:
@@ -6376,36 +7784,6 @@ public:
 	const LDKC2Tuple_u32TxOutZ* operator &() const { return &self; }
 	const LDKC2Tuple_u32TxOutZ* operator ->() const { return &self; }
 };
-class CResult_UpdateFailHTLCDecodeErrorZ {
-private:
-	LDKCResult_UpdateFailHTLCDecodeErrorZ self;
-public:
-	CResult_UpdateFailHTLCDecodeErrorZ(const CResult_UpdateFailHTLCDecodeErrorZ&) = delete;
-	CResult_UpdateFailHTLCDecodeErrorZ(CResult_UpdateFailHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateFailHTLCDecodeErrorZ)); }
-	CResult_UpdateFailHTLCDecodeErrorZ(LDKCResult_UpdateFailHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ)); }
-	operator LDKCResult_UpdateFailHTLCDecodeErrorZ() && { LDKCResult_UpdateFailHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ)); return res; }
-	~CResult_UpdateFailHTLCDecodeErrorZ() { CResult_UpdateFailHTLCDecodeErrorZ_free(self); }
-	CResult_UpdateFailHTLCDecodeErrorZ& operator=(CResult_UpdateFailHTLCDecodeErrorZ&& o) { CResult_UpdateFailHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateFailHTLCDecodeErrorZ)); return *this; }
-	LDKCResult_UpdateFailHTLCDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_UpdateFailHTLCDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_UpdateFailHTLCDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_UpdateFailHTLCDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_InvoiceParseOrSemanticErrorZ {
-private:
-	LDKCResult_InvoiceParseOrSemanticErrorZ self;
-public:
-	CResult_InvoiceParseOrSemanticErrorZ(const CResult_InvoiceParseOrSemanticErrorZ&) = delete;
-	CResult_InvoiceParseOrSemanticErrorZ(CResult_InvoiceParseOrSemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceParseOrSemanticErrorZ)); }
-	CResult_InvoiceParseOrSemanticErrorZ(LDKCResult_InvoiceParseOrSemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceParseOrSemanticErrorZ)); }
-	operator LDKCResult_InvoiceParseOrSemanticErrorZ() && { LDKCResult_InvoiceParseOrSemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceParseOrSemanticErrorZ)); return res; }
-	~CResult_InvoiceParseOrSemanticErrorZ() { CResult_InvoiceParseOrSemanticErrorZ_free(self); }
-	CResult_InvoiceParseOrSemanticErrorZ& operator=(CResult_InvoiceParseOrSemanticErrorZ&& o) { CResult_InvoiceParseOrSemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceParseOrSemanticErrorZ)); return *this; }
-	LDKCResult_InvoiceParseOrSemanticErrorZ* operator &() { return &self; }
-	LDKCResult_InvoiceParseOrSemanticErrorZ* operator ->() { return &self; }
-	const LDKCResult_InvoiceParseOrSemanticErrorZ* operator &() const { return &self; }
-	const LDKCResult_InvoiceParseOrSemanticErrorZ* operator ->() const { return &self; }
-};
 class CResult_PaymentSecretNoneZ {
 private:
 	LDKCResult_PaymentSecretNoneZ self;
@@ -6451,50 +7829,20 @@ public:
 	const LDKCVec_PrivateRouteZ* operator &() const { return &self; }
 	const LDKCVec_PrivateRouteZ* operator ->() const { return &self; }
 };
-class CResult_SpendableOutputDescriptorDecodeErrorZ {
-private:
-	LDKCResult_SpendableOutputDescriptorDecodeErrorZ self;
-public:
-	CResult_SpendableOutputDescriptorDecodeErrorZ(const CResult_SpendableOutputDescriptorDecodeErrorZ&) = delete;
-	CResult_SpendableOutputDescriptorDecodeErrorZ(CResult_SpendableOutputDescriptorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SpendableOutputDescriptorDecodeErrorZ)); }
-	CResult_SpendableOutputDescriptorDecodeErrorZ(LDKCResult_SpendableOutputDescriptorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ)); }
-	operator LDKCResult_SpendableOutputDescriptorDecodeErrorZ() && { LDKCResult_SpendableOutputDescriptorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ)); return res; }
-	~CResult_SpendableOutputDescriptorDecodeErrorZ() { CResult_SpendableOutputDescriptorDecodeErrorZ_free(self); }
-	CResult_SpendableOutputDescriptorDecodeErrorZ& operator=(CResult_SpendableOutputDescriptorDecodeErrorZ&& o) { CResult_SpendableOutputDescriptorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SpendableOutputDescriptorDecodeErrorZ)); return *this; }
-	LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_RevokeAndACKDecodeErrorZ {
-private:
-	LDKCResult_RevokeAndACKDecodeErrorZ self;
-public:
-	CResult_RevokeAndACKDecodeErrorZ(const CResult_RevokeAndACKDecodeErrorZ&) = delete;
-	CResult_RevokeAndACKDecodeErrorZ(CResult_RevokeAndACKDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RevokeAndACKDecodeErrorZ)); }
-	CResult_RevokeAndACKDecodeErrorZ(LDKCResult_RevokeAndACKDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RevokeAndACKDecodeErrorZ)); }
-	operator LDKCResult_RevokeAndACKDecodeErrorZ() && { LDKCResult_RevokeAndACKDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RevokeAndACKDecodeErrorZ)); return res; }
-	~CResult_RevokeAndACKDecodeErrorZ() { CResult_RevokeAndACKDecodeErrorZ_free(self); }
-	CResult_RevokeAndACKDecodeErrorZ& operator=(CResult_RevokeAndACKDecodeErrorZ&& o) { CResult_RevokeAndACKDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RevokeAndACKDecodeErrorZ)); return *this; }
-	LDKCResult_RevokeAndACKDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_RevokeAndACKDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_RevokeAndACKDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_RevokeAndACKDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_UnsignedChannelUpdateDecodeErrorZ {
+class CResult_BlindedPathNoneZ {
 private:
-	LDKCResult_UnsignedChannelUpdateDecodeErrorZ self;
+	LDKCResult_BlindedPathNoneZ self;
 public:
-	CResult_UnsignedChannelUpdateDecodeErrorZ(const CResult_UnsignedChannelUpdateDecodeErrorZ&) = delete;
-	CResult_UnsignedChannelUpdateDecodeErrorZ(CResult_UnsignedChannelUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnsignedChannelUpdateDecodeErrorZ)); }
-	CResult_UnsignedChannelUpdateDecodeErrorZ(LDKCResult_UnsignedChannelUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ)); }
-	operator LDKCResult_UnsignedChannelUpdateDecodeErrorZ() && { LDKCResult_UnsignedChannelUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ)); return res; }
-	~CResult_UnsignedChannelUpdateDecodeErrorZ() { CResult_UnsignedChannelUpdateDecodeErrorZ_free(self); }
-	CResult_UnsignedChannelUpdateDecodeErrorZ& operator=(CResult_UnsignedChannelUpdateDecodeErrorZ&& o) { CResult_UnsignedChannelUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnsignedChannelUpdateDecodeErrorZ)); return *this; }
-	LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator ->() const { return &self; }
+	CResult_BlindedPathNoneZ(const CResult_BlindedPathNoneZ&) = delete;
+	CResult_BlindedPathNoneZ(CResult_BlindedPathNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedPathNoneZ)); }
+	CResult_BlindedPathNoneZ(LDKCResult_BlindedPathNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedPathNoneZ)); }
+	operator LDKCResult_BlindedPathNoneZ() && { LDKCResult_BlindedPathNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedPathNoneZ)); return res; }
+	~CResult_BlindedPathNoneZ() { CResult_BlindedPathNoneZ_free(self); }
+	CResult_BlindedPathNoneZ& operator=(CResult_BlindedPathNoneZ&& o) { CResult_BlindedPathNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedPathNoneZ)); return *this; }
+	LDKCResult_BlindedPathNoneZ* operator &() { return &self; }
+	LDKCResult_BlindedPathNoneZ* operator ->() { return &self; }
+	const LDKCResult_BlindedPathNoneZ* operator &() const { return &self; }
+	const LDKCResult_BlindedPathNoneZ* operator ->() const { return &self; }
 };
 class CResult_ShutdownDecodeErrorZ {
 private:
@@ -6511,35 +7859,20 @@ public:
 	const LDKCResult_ShutdownDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_ShutdownDecodeErrorZ* operator ->() const { return &self; }
 };
-class CVec_EventZ {
-private:
-	LDKCVec_EventZ self;
-public:
-	CVec_EventZ(const CVec_EventZ&) = delete;
-	CVec_EventZ(CVec_EventZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_EventZ)); }
-	CVec_EventZ(LDKCVec_EventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_EventZ)); }
-	operator LDKCVec_EventZ() && { LDKCVec_EventZ res = self; memset(&self, 0, sizeof(LDKCVec_EventZ)); return res; }
-	~CVec_EventZ() { CVec_EventZ_free(self); }
-	CVec_EventZ& operator=(CVec_EventZ&& o) { CVec_EventZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_EventZ)); return *this; }
-	LDKCVec_EventZ* operator &() { return &self; }
-	LDKCVec_EventZ* operator ->() { return &self; }
-	const LDKCVec_EventZ* operator &() const { return &self; }
-	const LDKCVec_EventZ* operator ->() const { return &self; }
-};
-class CResult_NoneSemanticErrorZ {
+class CResult_TxOutUtxoLookupErrorZ {
 private:
-	LDKCResult_NoneSemanticErrorZ self;
+	LDKCResult_TxOutUtxoLookupErrorZ self;
 public:
-	CResult_NoneSemanticErrorZ(const CResult_NoneSemanticErrorZ&) = delete;
-	CResult_NoneSemanticErrorZ(CResult_NoneSemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneSemanticErrorZ)); }
-	CResult_NoneSemanticErrorZ(LDKCResult_NoneSemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneSemanticErrorZ)); }
-	operator LDKCResult_NoneSemanticErrorZ() && { LDKCResult_NoneSemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneSemanticErrorZ)); return res; }
-	~CResult_NoneSemanticErrorZ() { CResult_NoneSemanticErrorZ_free(self); }
-	CResult_NoneSemanticErrorZ& operator=(CResult_NoneSemanticErrorZ&& o) { CResult_NoneSemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneSemanticErrorZ)); return *this; }
-	LDKCResult_NoneSemanticErrorZ* operator &() { return &self; }
-	LDKCResult_NoneSemanticErrorZ* operator ->() { return &self; }
-	const LDKCResult_NoneSemanticErrorZ* operator &() const { return &self; }
-	const LDKCResult_NoneSemanticErrorZ* operator ->() const { return &self; }
+	CResult_TxOutUtxoLookupErrorZ(const CResult_TxOutUtxoLookupErrorZ&) = delete;
+	CResult_TxOutUtxoLookupErrorZ(CResult_TxOutUtxoLookupErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxOutUtxoLookupErrorZ)); }
+	CResult_TxOutUtxoLookupErrorZ(LDKCResult_TxOutUtxoLookupErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxOutUtxoLookupErrorZ)); }
+	operator LDKCResult_TxOutUtxoLookupErrorZ() && { LDKCResult_TxOutUtxoLookupErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxOutUtxoLookupErrorZ)); return res; }
+	~CResult_TxOutUtxoLookupErrorZ() { CResult_TxOutUtxoLookupErrorZ_free(self); }
+	CResult_TxOutUtxoLookupErrorZ& operator=(CResult_TxOutUtxoLookupErrorZ&& o) { CResult_TxOutUtxoLookupErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxOutUtxoLookupErrorZ)); return *this; }
+	LDKCResult_TxOutUtxoLookupErrorZ* operator &() { return &self; }
+	LDKCResult_TxOutUtxoLookupErrorZ* operator ->() { return &self; }
+	const LDKCResult_TxOutUtxoLookupErrorZ* operator &() const { return &self; }
+	const LDKCResult_TxOutUtxoLookupErrorZ* operator ->() const { return &self; }
 };
 class CVec_MonitorEventZ {
 private:
@@ -6571,51 +7904,6 @@ public:
 	const LDKCVec_PaymentPreimageZ* operator &() const { return &self; }
 	const LDKCVec_PaymentPreimageZ* operator ->() const { return &self; }
 };
-class CVec_C2Tuple_u32ScriptZZ {
-private:
-	LDKCVec_C2Tuple_u32ScriptZZ self;
-public:
-	CVec_C2Tuple_u32ScriptZZ(const CVec_C2Tuple_u32ScriptZZ&) = delete;
-	CVec_C2Tuple_u32ScriptZZ(CVec_C2Tuple_u32ScriptZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_u32ScriptZZ)); }
-	CVec_C2Tuple_u32ScriptZZ(LDKCVec_C2Tuple_u32ScriptZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_u32ScriptZZ)); }
-	operator LDKCVec_C2Tuple_u32ScriptZZ() && { LDKCVec_C2Tuple_u32ScriptZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_u32ScriptZZ)); return res; }
-	~CVec_C2Tuple_u32ScriptZZ() { CVec_C2Tuple_u32ScriptZZ_free(self); }
-	CVec_C2Tuple_u32ScriptZZ& operator=(CVec_C2Tuple_u32ScriptZZ&& o) { CVec_C2Tuple_u32ScriptZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_u32ScriptZZ)); return *this; }
-	LDKCVec_C2Tuple_u32ScriptZZ* operator &() { return &self; }
-	LDKCVec_C2Tuple_u32ScriptZZ* operator ->() { return &self; }
-	const LDKCVec_C2Tuple_u32ScriptZZ* operator &() const { return &self; }
-	const LDKCVec_C2Tuple_u32ScriptZZ* operator ->() const { return &self; }
-};
-class CResult_NoneChannelMonitorUpdateErrZ {
-private:
-	LDKCResult_NoneChannelMonitorUpdateErrZ self;
-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;
-public:
-	CResult_COption_ClosureReasonZDecodeErrorZ(const CResult_COption_ClosureReasonZDecodeErrorZ&) = delete;
-	CResult_COption_ClosureReasonZDecodeErrorZ(CResult_COption_ClosureReasonZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_ClosureReasonZDecodeErrorZ)); }
-	CResult_COption_ClosureReasonZDecodeErrorZ(LDKCResult_COption_ClosureReasonZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ)); }
-	operator LDKCResult_COption_ClosureReasonZDecodeErrorZ() && { LDKCResult_COption_ClosureReasonZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ)); return res; }
-	~CResult_COption_ClosureReasonZDecodeErrorZ() { CResult_COption_ClosureReasonZDecodeErrorZ_free(self); }
-	CResult_COption_ClosureReasonZDecodeErrorZ& operator=(CResult_COption_ClosureReasonZDecodeErrorZ&& o) { CResult_COption_ClosureReasonZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_ClosureReasonZDecodeErrorZ)); return *this; }
-	LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator ->() const { return &self; }
-};
 class CResult_PublicKeyErrorZ {
 private:
 	LDKCResult_PublicKeyErrorZ self;
@@ -6631,20 +7919,20 @@ public:
 	const LDKCResult_PublicKeyErrorZ* operator &() const { return &self; }
 	const LDKCResult_PublicKeyErrorZ* operator ->() const { return &self; }
 };
-class C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ {
+class CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ {
 private:
-	LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ self;
+	LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ self;
 public:
-	C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(const C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&) = delete;
-	C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); }
-	C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); }
-	operator LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ() && { LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); return res; }
-	~C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ() { C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(self); }
-	C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ& operator=(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&& o) { C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(self); self = o.self; memset(&o, 0, sizeof(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); return *this; }
-	LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator &() { return &self; }
-	LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator ->() { return &self; }
-	const LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator &() const { return &self; }
-	const LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator ->() const { return &self; }
+	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 CResult_NoneNoneZ {
 private:
@@ -6661,21 +7949,6 @@ public:
 	const LDKCResult_NoneNoneZ* operator &() const { return &self; }
 	const LDKCResult_NoneNoneZ* operator ->() const { return &self; }
 };
-class CResult_RouteParametersDecodeErrorZ {
-private:
-	LDKCResult_RouteParametersDecodeErrorZ self;
-public:
-	CResult_RouteParametersDecodeErrorZ(const CResult_RouteParametersDecodeErrorZ&) = delete;
-	CResult_RouteParametersDecodeErrorZ(CResult_RouteParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteParametersDecodeErrorZ)); }
-	CResult_RouteParametersDecodeErrorZ(LDKCResult_RouteParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteParametersDecodeErrorZ)); }
-	operator LDKCResult_RouteParametersDecodeErrorZ() && { LDKCResult_RouteParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteParametersDecodeErrorZ)); return res; }
-	~CResult_RouteParametersDecodeErrorZ() { CResult_RouteParametersDecodeErrorZ_free(self); }
-	CResult_RouteParametersDecodeErrorZ& operator=(CResult_RouteParametersDecodeErrorZ&& o) { CResult_RouteParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteParametersDecodeErrorZ)); return *this; }
-	LDKCResult_RouteParametersDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_RouteParametersDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_RouteParametersDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_RouteParametersDecodeErrorZ* operator ->() const { return &self; }
-};
 class COption_ClosureReasonZ {
 private:
 	LDKCOption_ClosureReasonZ self;
@@ -6691,110 +7964,50 @@ public:
 	const LDKCOption_ClosureReasonZ* operator &() const { return &self; }
 	const LDKCOption_ClosureReasonZ* operator ->() const { return &self; }
 };
-class CResult_NodeAliasDecodeErrorZ {
+class COption_u128Z {
 private:
-	LDKCResult_NodeAliasDecodeErrorZ self;
+	LDKCOption_u128Z self;
 public:
-	CResult_NodeAliasDecodeErrorZ(const CResult_NodeAliasDecodeErrorZ&) = delete;
-	CResult_NodeAliasDecodeErrorZ(CResult_NodeAliasDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeAliasDecodeErrorZ)); }
-	CResult_NodeAliasDecodeErrorZ(LDKCResult_NodeAliasDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeAliasDecodeErrorZ)); }
-	operator LDKCResult_NodeAliasDecodeErrorZ() && { LDKCResult_NodeAliasDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeAliasDecodeErrorZ)); return res; }
-	~CResult_NodeAliasDecodeErrorZ() { CResult_NodeAliasDecodeErrorZ_free(self); }
-	CResult_NodeAliasDecodeErrorZ& operator=(CResult_NodeAliasDecodeErrorZ&& o) { CResult_NodeAliasDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeAliasDecodeErrorZ)); return *this; }
-	LDKCResult_NodeAliasDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_NodeAliasDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_NodeAliasDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_NodeAliasDecodeErrorZ* operator ->() const { return &self; }
+	COption_u128Z(const COption_u128Z&) = delete;
+	COption_u128Z(COption_u128Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_u128Z)); }
+	COption_u128Z(LDKCOption_u128Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_u128Z)); }
+	operator LDKCOption_u128Z() && { LDKCOption_u128Z res = self; memset(&self, 0, sizeof(LDKCOption_u128Z)); return res; }
+	~COption_u128Z() { COption_u128Z_free(self); }
+	COption_u128Z& operator=(COption_u128Z&& o) { COption_u128Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_u128Z)); return *this; }
+	LDKCOption_u128Z* operator &() { return &self; }
+	LDKCOption_u128Z* operator ->() { return &self; }
+	const LDKCOption_u128Z* operator &() const { return &self; }
+	const LDKCOption_u128Z* operator ->() const { return &self; }
 };
 class CVec_APIErrorZ {
-private:
-	LDKCVec_APIErrorZ self;
-public:
-	CVec_APIErrorZ(const CVec_APIErrorZ&) = delete;
-	CVec_APIErrorZ(CVec_APIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_APIErrorZ)); }
-	CVec_APIErrorZ(LDKCVec_APIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_APIErrorZ)); }
-	operator LDKCVec_APIErrorZ() && { LDKCVec_APIErrorZ res = self; memset(&self, 0, sizeof(LDKCVec_APIErrorZ)); return res; }
-	~CVec_APIErrorZ() { CVec_APIErrorZ_free(self); }
-	CVec_APIErrorZ& operator=(CVec_APIErrorZ&& o) { CVec_APIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_APIErrorZ)); return *this; }
-	LDKCVec_APIErrorZ* operator &() { return &self; }
-	LDKCVec_APIErrorZ* operator ->() { return &self; }
-	const LDKCVec_APIErrorZ* operator &() const { return &self; }
-	const LDKCVec_APIErrorZ* operator ->() const { return &self; }
-};
-class CResult_PrivateRouteCreationErrorZ {
-private:
-	LDKCResult_PrivateRouteCreationErrorZ self;
-public:
-	CResult_PrivateRouteCreationErrorZ(const CResult_PrivateRouteCreationErrorZ&) = delete;
-	CResult_PrivateRouteCreationErrorZ(CResult_PrivateRouteCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PrivateRouteCreationErrorZ)); }
-	CResult_PrivateRouteCreationErrorZ(LDKCResult_PrivateRouteCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PrivateRouteCreationErrorZ)); }
-	operator LDKCResult_PrivateRouteCreationErrorZ() && { LDKCResult_PrivateRouteCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PrivateRouteCreationErrorZ)); return res; }
-	~CResult_PrivateRouteCreationErrorZ() { CResult_PrivateRouteCreationErrorZ_free(self); }
-	CResult_PrivateRouteCreationErrorZ& operator=(CResult_PrivateRouteCreationErrorZ&& o) { CResult_PrivateRouteCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PrivateRouteCreationErrorZ)); return *this; }
-	LDKCResult_PrivateRouteCreationErrorZ* operator &() { return &self; }
-	LDKCResult_PrivateRouteCreationErrorZ* operator ->() { return &self; }
-	const LDKCResult_PrivateRouteCreationErrorZ* operator &() const { return &self; }
-	const LDKCResult_PrivateRouteCreationErrorZ* operator ->() const { return &self; }
-};
-class CResult_boolPeerHandleErrorZ {
-private:
-	LDKCResult_boolPeerHandleErrorZ self;
-public:
-	CResult_boolPeerHandleErrorZ(const CResult_boolPeerHandleErrorZ&) = delete;
-	CResult_boolPeerHandleErrorZ(CResult_boolPeerHandleErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_boolPeerHandleErrorZ)); }
-	CResult_boolPeerHandleErrorZ(LDKCResult_boolPeerHandleErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_boolPeerHandleErrorZ)); }
-	operator LDKCResult_boolPeerHandleErrorZ() && { LDKCResult_boolPeerHandleErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_boolPeerHandleErrorZ)); return res; }
-	~CResult_boolPeerHandleErrorZ() { CResult_boolPeerHandleErrorZ_free(self); }
-	CResult_boolPeerHandleErrorZ& operator=(CResult_boolPeerHandleErrorZ&& o) { CResult_boolPeerHandleErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_boolPeerHandleErrorZ)); return *this; }
-	LDKCResult_boolPeerHandleErrorZ* operator &() { return &self; }
-	LDKCResult_boolPeerHandleErrorZ* operator ->() { return &self; }
-	const LDKCResult_boolPeerHandleErrorZ* operator &() const { return &self; }
-	const LDKCResult_boolPeerHandleErrorZ* operator ->() const { return &self; }
-};
-class CVec_UpdateFulfillHTLCZ {
-private:
-	LDKCVec_UpdateFulfillHTLCZ self;
-public:
-	CVec_UpdateFulfillHTLCZ(const CVec_UpdateFulfillHTLCZ&) = delete;
-	CVec_UpdateFulfillHTLCZ(CVec_UpdateFulfillHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateFulfillHTLCZ)); }
-	CVec_UpdateFulfillHTLCZ(LDKCVec_UpdateFulfillHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateFulfillHTLCZ)); }
-	operator LDKCVec_UpdateFulfillHTLCZ() && { LDKCVec_UpdateFulfillHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateFulfillHTLCZ)); return res; }
-	~CVec_UpdateFulfillHTLCZ() { CVec_UpdateFulfillHTLCZ_free(self); }
-	CVec_UpdateFulfillHTLCZ& operator=(CVec_UpdateFulfillHTLCZ&& o) { CVec_UpdateFulfillHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateFulfillHTLCZ)); return *this; }
-	LDKCVec_UpdateFulfillHTLCZ* operator &() { return &self; }
-	LDKCVec_UpdateFulfillHTLCZ* operator ->() { return &self; }
-	const LDKCVec_UpdateFulfillHTLCZ* operator &() const { return &self; }
-	const LDKCVec_UpdateFulfillHTLCZ* operator ->() const { return &self; }
-};
-class CResult_AnnouncementSignaturesDecodeErrorZ {
-private:
-	LDKCResult_AnnouncementSignaturesDecodeErrorZ self;
-public:
-	CResult_AnnouncementSignaturesDecodeErrorZ(const CResult_AnnouncementSignaturesDecodeErrorZ&) = delete;
-	CResult_AnnouncementSignaturesDecodeErrorZ(CResult_AnnouncementSignaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_AnnouncementSignaturesDecodeErrorZ)); }
-	CResult_AnnouncementSignaturesDecodeErrorZ(LDKCResult_AnnouncementSignaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ)); }
-	operator LDKCResult_AnnouncementSignaturesDecodeErrorZ() && { LDKCResult_AnnouncementSignaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ)); return res; }
-	~CResult_AnnouncementSignaturesDecodeErrorZ() { CResult_AnnouncementSignaturesDecodeErrorZ_free(self); }
-	CResult_AnnouncementSignaturesDecodeErrorZ& operator=(CResult_AnnouncementSignaturesDecodeErrorZ&& o) { CResult_AnnouncementSignaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_AnnouncementSignaturesDecodeErrorZ)); return *this; }
-	LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator ->() const { return &self; }
+private:
+	LDKCVec_APIErrorZ self;
+public:
+	CVec_APIErrorZ(const CVec_APIErrorZ&) = delete;
+	CVec_APIErrorZ(CVec_APIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_APIErrorZ)); }
+	CVec_APIErrorZ(LDKCVec_APIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_APIErrorZ)); }
+	operator LDKCVec_APIErrorZ() && { LDKCVec_APIErrorZ res = self; memset(&self, 0, sizeof(LDKCVec_APIErrorZ)); return res; }
+	~CVec_APIErrorZ() { CVec_APIErrorZ_free(self); }
+	CVec_APIErrorZ& operator=(CVec_APIErrorZ&& o) { CVec_APIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_APIErrorZ)); return *this; }
+	LDKCVec_APIErrorZ* operator &() { return &self; }
+	LDKCVec_APIErrorZ* operator ->() { return &self; }
+	const LDKCVec_APIErrorZ* operator &() const { return &self; }
+	const LDKCVec_APIErrorZ* operator ->() const { return &self; }
 };
-class CResult_UpdateFulfillHTLCDecodeErrorZ {
+class CResult_boolPeerHandleErrorZ {
 private:
-	LDKCResult_UpdateFulfillHTLCDecodeErrorZ self;
+	LDKCResult_boolPeerHandleErrorZ self;
 public:
-	CResult_UpdateFulfillHTLCDecodeErrorZ(const CResult_UpdateFulfillHTLCDecodeErrorZ&) = delete;
-	CResult_UpdateFulfillHTLCDecodeErrorZ(CResult_UpdateFulfillHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateFulfillHTLCDecodeErrorZ)); }
-	CResult_UpdateFulfillHTLCDecodeErrorZ(LDKCResult_UpdateFulfillHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ)); }
-	operator LDKCResult_UpdateFulfillHTLCDecodeErrorZ() && { LDKCResult_UpdateFulfillHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ)); return res; }
-	~CResult_UpdateFulfillHTLCDecodeErrorZ() { CResult_UpdateFulfillHTLCDecodeErrorZ_free(self); }
-	CResult_UpdateFulfillHTLCDecodeErrorZ& operator=(CResult_UpdateFulfillHTLCDecodeErrorZ&& o) { CResult_UpdateFulfillHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateFulfillHTLCDecodeErrorZ)); return *this; }
-	LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator ->() const { return &self; }
+	CResult_boolPeerHandleErrorZ(const CResult_boolPeerHandleErrorZ&) = delete;
+	CResult_boolPeerHandleErrorZ(CResult_boolPeerHandleErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_boolPeerHandleErrorZ)); }
+	CResult_boolPeerHandleErrorZ(LDKCResult_boolPeerHandleErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_boolPeerHandleErrorZ)); }
+	operator LDKCResult_boolPeerHandleErrorZ() && { LDKCResult_boolPeerHandleErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_boolPeerHandleErrorZ)); return res; }
+	~CResult_boolPeerHandleErrorZ() { CResult_boolPeerHandleErrorZ_free(self); }
+	CResult_boolPeerHandleErrorZ& operator=(CResult_boolPeerHandleErrorZ&& o) { CResult_boolPeerHandleErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_boolPeerHandleErrorZ)); return *this; }
+	LDKCResult_boolPeerHandleErrorZ* operator &() { return &self; }
+	LDKCResult_boolPeerHandleErrorZ* operator ->() { return &self; }
+	const LDKCResult_boolPeerHandleErrorZ* operator &() const { return &self; }
+	const LDKCResult_boolPeerHandleErrorZ* operator ->() const { return &self; }
 };
 class CResult_ChannelUpdateDecodeErrorZ {
 private:
@@ -6811,51 +8024,6 @@ public:
 	const LDKCResult_ChannelUpdateDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_ChannelUpdateDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_NodeFeaturesDecodeErrorZ {
-private:
-	LDKCResult_NodeFeaturesDecodeErrorZ self;
-public:
-	CResult_NodeFeaturesDecodeErrorZ(const CResult_NodeFeaturesDecodeErrorZ&) = delete;
-	CResult_NodeFeaturesDecodeErrorZ(CResult_NodeFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeFeaturesDecodeErrorZ)); }
-	CResult_NodeFeaturesDecodeErrorZ(LDKCResult_NodeFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeFeaturesDecodeErrorZ)); }
-	operator LDKCResult_NodeFeaturesDecodeErrorZ() && { LDKCResult_NodeFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeFeaturesDecodeErrorZ)); return res; }
-	~CResult_NodeFeaturesDecodeErrorZ() { CResult_NodeFeaturesDecodeErrorZ_free(self); }
-	CResult_NodeFeaturesDecodeErrorZ& operator=(CResult_NodeFeaturesDecodeErrorZ&& o) { CResult_NodeFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeFeaturesDecodeErrorZ)); return *this; }
-	LDKCResult_NodeFeaturesDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_NodeFeaturesDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_NodeFeaturesDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_NodeFeaturesDecodeErrorZ* operator ->() const { return &self; }
-};
-class CVec_u5Z {
-private:
-	LDKCVec_u5Z self;
-public:
-	CVec_u5Z(const CVec_u5Z&) = delete;
-	CVec_u5Z(CVec_u5Z&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_u5Z)); }
-	CVec_u5Z(LDKCVec_u5Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_u5Z)); }
-	operator LDKCVec_u5Z() && { LDKCVec_u5Z res = self; memset(&self, 0, sizeof(LDKCVec_u5Z)); return res; }
-	~CVec_u5Z() { CVec_u5Z_free(self); }
-	CVec_u5Z& operator=(CVec_u5Z&& o) { CVec_u5Z_free(self); self = o.self; memset(&o, 0, sizeof(CVec_u5Z)); return *this; }
-	LDKCVec_u5Z* operator &() { return &self; }
-	LDKCVec_u5Z* operator ->() { return &self; }
-	const LDKCVec_u5Z* operator &() const { return &self; }
-	const LDKCVec_u5Z* operator ->() const { return &self; }
-};
-class CResult_InMemorySignerDecodeErrorZ {
-private:
-	LDKCResult_InMemorySignerDecodeErrorZ self;
-public:
-	CResult_InMemorySignerDecodeErrorZ(const CResult_InMemorySignerDecodeErrorZ&) = delete;
-	CResult_InMemorySignerDecodeErrorZ(CResult_InMemorySignerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InMemorySignerDecodeErrorZ)); }
-	CResult_InMemorySignerDecodeErrorZ(LDKCResult_InMemorySignerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InMemorySignerDecodeErrorZ)); }
-	operator LDKCResult_InMemorySignerDecodeErrorZ() && { LDKCResult_InMemorySignerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InMemorySignerDecodeErrorZ)); return res; }
-	~CResult_InMemorySignerDecodeErrorZ() { CResult_InMemorySignerDecodeErrorZ_free(self); }
-	CResult_InMemorySignerDecodeErrorZ& operator=(CResult_InMemorySignerDecodeErrorZ&& o) { CResult_InMemorySignerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InMemorySignerDecodeErrorZ)); return *this; }
-	LDKCResult_InMemorySignerDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_InMemorySignerDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_InMemorySignerDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_InMemorySignerDecodeErrorZ* operator ->() const { return &self; }
-};
 class CResult_PaymentSecretAPIErrorZ {
 private:
 	LDKCResult_PaymentSecretAPIErrorZ self;
@@ -6886,6 +8054,21 @@ public:
 	const LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* 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_SignedRawInvoiceParseErrorZ {
 private:
 	LDKCResult_SignedRawInvoiceParseErrorZ self;
@@ -6901,20 +8084,20 @@ public:
 	const LDKCResult_SignedRawInvoiceParseErrorZ* operator &() const { return &self; }
 	const LDKCResult_SignedRawInvoiceParseErrorZ* operator ->() const { return &self; }
 };
-class C2Tuple_u32ScriptZ {
+class COption_C2Tuple_EightU16sEightU16sZZ {
 private:
-	LDKC2Tuple_u32ScriptZ self;
+	LDKCOption_C2Tuple_EightU16sEightU16sZZ 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; }
+	COption_C2Tuple_EightU16sEightU16sZZ(const COption_C2Tuple_EightU16sEightU16sZZ&) = delete;
+	COption_C2Tuple_EightU16sEightU16sZZ(COption_C2Tuple_EightU16sEightU16sZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_C2Tuple_EightU16sEightU16sZZ)); }
+	COption_C2Tuple_EightU16sEightU16sZZ(LDKCOption_C2Tuple_EightU16sEightU16sZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_C2Tuple_EightU16sEightU16sZZ)); }
+	operator LDKCOption_C2Tuple_EightU16sEightU16sZZ() && { LDKCOption_C2Tuple_EightU16sEightU16sZZ res = self; memset(&self, 0, sizeof(LDKCOption_C2Tuple_EightU16sEightU16sZZ)); return res; }
+	~COption_C2Tuple_EightU16sEightU16sZZ() { COption_C2Tuple_EightU16sEightU16sZZ_free(self); }
+	COption_C2Tuple_EightU16sEightU16sZZ& operator=(COption_C2Tuple_EightU16sEightU16sZZ&& o) { COption_C2Tuple_EightU16sEightU16sZZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_C2Tuple_EightU16sEightU16sZZ)); return *this; }
+	LDKCOption_C2Tuple_EightU16sEightU16sZZ* operator &() { return &self; }
+	LDKCOption_C2Tuple_EightU16sEightU16sZZ* operator ->() { return &self; }
+	const LDKCOption_C2Tuple_EightU16sEightU16sZZ* operator &() const { return &self; }
+	const LDKCOption_C2Tuple_EightU16sEightU16sZZ* operator ->() const { return &self; }
 };
 class CResult_RouteDecodeErrorZ {
 private:
@@ -6931,21 +8114,6 @@ public:
 	const LDKCResult_RouteDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_RouteDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_BuiltCommitmentTransactionDecodeErrorZ {
-private:
-	LDKCResult_BuiltCommitmentTransactionDecodeErrorZ self;
-public:
-	CResult_BuiltCommitmentTransactionDecodeErrorZ(const CResult_BuiltCommitmentTransactionDecodeErrorZ&) = delete;
-	CResult_BuiltCommitmentTransactionDecodeErrorZ(CResult_BuiltCommitmentTransactionDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BuiltCommitmentTransactionDecodeErrorZ)); }
-	CResult_BuiltCommitmentTransactionDecodeErrorZ(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ)); }
-	operator LDKCResult_BuiltCommitmentTransactionDecodeErrorZ() && { LDKCResult_BuiltCommitmentTransactionDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ)); return res; }
-	~CResult_BuiltCommitmentTransactionDecodeErrorZ() { CResult_BuiltCommitmentTransactionDecodeErrorZ_free(self); }
-	CResult_BuiltCommitmentTransactionDecodeErrorZ& operator=(CResult_BuiltCommitmentTransactionDecodeErrorZ&& o) { CResult_BuiltCommitmentTransactionDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BuiltCommitmentTransactionDecodeErrorZ)); return *this; }
-	LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator ->() const { return &self; }
-};
 class COption_NoneZ {
 private:
 	LDKCOption_NoneZ self;
@@ -6961,97 +8129,15 @@ public:
 	const LDKCOption_NoneZ* operator &() const { return &self; }
 	const LDKCOption_NoneZ* operator ->() const { return &self; }
 };
-class CVec_TxOutZ {
-private:
-	LDKCVec_TxOutZ self;
-public:
-	CVec_TxOutZ(const CVec_TxOutZ&) = delete;
-	CVec_TxOutZ(CVec_TxOutZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TxOutZ)); }
-	CVec_TxOutZ(LDKCVec_TxOutZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TxOutZ)); }
-	operator LDKCVec_TxOutZ() && { LDKCVec_TxOutZ res = self; memset(&self, 0, sizeof(LDKCVec_TxOutZ)); return res; }
-	~CVec_TxOutZ() { CVec_TxOutZ_free(self); }
-	CVec_TxOutZ& operator=(CVec_TxOutZ&& o) { CVec_TxOutZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TxOutZ)); return *this; }
-	LDKCVec_TxOutZ* operator &() { return &self; }
-	LDKCVec_TxOutZ* operator ->() { return &self; }
-	const LDKCVec_TxOutZ* operator &() const { return &self; }
-	const LDKCVec_TxOutZ* operator ->() const { return &self; }
-};
-class CResult_ChannelUpdateInfoDecodeErrorZ {
-private:
-	LDKCResult_ChannelUpdateInfoDecodeErrorZ self;
-public:
-	CResult_ChannelUpdateInfoDecodeErrorZ(const CResult_ChannelUpdateInfoDecodeErrorZ&) = delete;
-	CResult_ChannelUpdateInfoDecodeErrorZ(CResult_ChannelUpdateInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelUpdateInfoDecodeErrorZ)); }
-	CResult_ChannelUpdateInfoDecodeErrorZ(LDKCResult_ChannelUpdateInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ)); }
-	operator LDKCResult_ChannelUpdateInfoDecodeErrorZ() && { LDKCResult_ChannelUpdateInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ)); return res; }
-	~CResult_ChannelUpdateInfoDecodeErrorZ() { CResult_ChannelUpdateInfoDecodeErrorZ_free(self); }
-	CResult_ChannelUpdateInfoDecodeErrorZ& operator=(CResult_ChannelUpdateInfoDecodeErrorZ&& o) { CResult_ChannelUpdateInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelUpdateInfoDecodeErrorZ)); return *this; }
-	LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator ->() const { return &self; }
-};
-class CVec_C2Tuple_OutPointCVec_MonitorEventZZZ {
-private:
-	LDKCVec_C2Tuple_OutPointCVec_MonitorEventZZZ 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; }
-};
-class CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ {
-private:
-	LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ self;
-public:
-	CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ(const CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ&) = delete;
-	CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ(CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ)); }
-	CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ)); }
-	operator LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ() && { LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ)); return res; }
-	~CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ() { CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(self); }
-	CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ& operator=(CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ&& o) { CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ)); return *this; }
-	LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* operator ->() const { return &self; }
-};
-class CVec_UpdateFailHTLCZ {
-private:
-	LDKCVec_UpdateFailHTLCZ self;
-public:
-	CVec_UpdateFailHTLCZ(const CVec_UpdateFailHTLCZ&) = delete;
-	CVec_UpdateFailHTLCZ(CVec_UpdateFailHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateFailHTLCZ)); }
-	CVec_UpdateFailHTLCZ(LDKCVec_UpdateFailHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateFailHTLCZ)); }
-	operator LDKCVec_UpdateFailHTLCZ() && { LDKCVec_UpdateFailHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateFailHTLCZ)); return res; }
-	~CVec_UpdateFailHTLCZ() { CVec_UpdateFailHTLCZ_free(self); }
-	CVec_UpdateFailHTLCZ& operator=(CVec_UpdateFailHTLCZ&& o) { CVec_UpdateFailHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateFailHTLCZ)); return *this; }
-	LDKCVec_UpdateFailHTLCZ* operator &() { return &self; }
-	LDKCVec_UpdateFailHTLCZ* operator ->() { return &self; }
-	const LDKCVec_UpdateFailHTLCZ* operator &() const { return &self; }
-	const LDKCVec_UpdateFailHTLCZ* operator ->() const { return &self; }
-};
-class CResult_ReplyShortChannelIdsEndDecodeErrorZ {
-private:
-	LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ self;
-public:
-	CResult_ReplyShortChannelIdsEndDecodeErrorZ(const CResult_ReplyShortChannelIdsEndDecodeErrorZ&) = delete;
-	CResult_ReplyShortChannelIdsEndDecodeErrorZ(CResult_ReplyShortChannelIdsEndDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ReplyShortChannelIdsEndDecodeErrorZ)); }
-	CResult_ReplyShortChannelIdsEndDecodeErrorZ(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ)); }
-	operator LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ() && { LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ)); return res; }
-	~CResult_ReplyShortChannelIdsEndDecodeErrorZ() { CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(self); }
-	CResult_ReplyShortChannelIdsEndDecodeErrorZ& operator=(CResult_ReplyShortChannelIdsEndDecodeErrorZ&& o) { CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ReplyShortChannelIdsEndDecodeErrorZ)); return *this; }
-	LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator ->() const { return &self; }
-};
 
+inline LDK::CResult_RouteLightningErrorZ Router::find_route(struct LDKPublicKey payer, const struct LDKRouteParameters *NONNULL_PTR route_params, struct LDKCVec_ChannelDetailsZ *first_hops, const struct LDKInFlightHtlcs *NONNULL_PTR inflight_htlcs) {
+	LDK::CResult_RouteLightningErrorZ ret = (self.find_route)(self.this_arg, payer, route_params, first_hops, inflight_htlcs);
+	return ret;
+}
+inline LDK::CResult_RouteLightningErrorZ Router::find_route_with_id(struct LDKPublicKey payer, const struct LDKRouteParameters *NONNULL_PTR route_params, struct LDKCVec_ChannelDetailsZ *first_hops, const struct LDKInFlightHtlcs *NONNULL_PTR inflight_htlcs, struct LDKThirtyTwoBytes _payment_hash, struct LDKThirtyTwoBytes _payment_id) {
+	LDK::CResult_RouteLightningErrorZ ret = (self.find_route_with_id)(self.this_arg, payer, route_params, first_hops, inflight_htlcs, _payment_hash, _payment_id);
+	return ret;
+}
 inline void BroadcasterInterface::broadcast_transaction(struct LDKTransaction tx) {
 	(self.broadcast_transaction)(self.this_arg, tx);
 }
@@ -7063,16 +8149,16 @@ 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);
 }
-inline void EventHandler::handle_event(const struct LDKEvent *NONNULL_PTR event) {
+inline void EventHandler::handle_event(struct LDKEvent event) {
 	(self.handle_event)(self.this_arg, event);
 }
-inline LDK::CResult_TxOutAccessErrorZ Access::get_utxo(const uint8_t (*genesis_hash)[32], uint64_t short_channel_id) {
-	LDK::CResult_TxOutAccessErrorZ ret = (self.get_utxo)(self.this_arg, genesis_hash, short_channel_id);
-	return ret;
-}
 inline void Listen::filtered_block_connected(const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height) {
 	(self.filtered_block_connected)(self.this_arg, header, txdata, height);
 }
@@ -7091,28 +8177,27 @@ inline void Confirm::transaction_unconfirmed(const uint8_t (*txid)[32]) {
 inline void Confirm::best_block_updated(const uint8_t (*header)[80], uint32_t height) {
 	(self.best_block_updated)(self.this_arg, header, height);
 }
-inline LDK::CVec_TxidZ Confirm::get_relevant_txids() {
-	LDK::CVec_TxidZ ret = (self.get_relevant_txids)(self.this_arg);
+inline LDK::CVec_C2Tuple_TxidBlockHashZZ Confirm::get_relevant_txids() {
+	LDK::CVec_C2Tuple_TxidBlockHashZZ 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, const struct LDKChannelMonitorUpdate *NONNULL_PTR 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,130 +8209,129 @@ 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 LDKPublicKey BaseSign::get_per_commitment_point(uint64_t idx) {
+inline uint64_t CustomOnionMessageContents::tlv_type() {
+	uint64_t ret = (self.tlv_type)(self.this_arg);
+	return ret;
+}
+inline LDKPublicKey ChannelSigner::get_per_commitment_point(uint64_t idx) {
 	LDKPublicKey ret = (self.get_per_commitment_point)(self.this_arg, idx);
 	return ret;
 }
-inline LDKThirtyTwoBytes BaseSign::release_commitment_secret(uint64_t idx) {
+inline LDKThirtyTwoBytes ChannelSigner::release_commitment_secret(uint64_t idx) {
 	LDKThirtyTwoBytes ret = (self.release_commitment_secret)(self.this_arg, idx);
 	return ret;
 }
-inline LDK::CResult_NoneNoneZ BaseSign::validate_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_PaymentPreimageZ preimages) {
+inline LDK::CResult_NoneNoneZ ChannelSigner::validate_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_PaymentPreimageZ preimages) {
 	LDK::CResult_NoneNoneZ ret = (self.validate_holder_commitment)(self.this_arg, holder_tx, preimages);
 	return ret;
 }
-inline LDKThirtyTwoBytes BaseSign::channel_keys_id() {
+inline LDKThirtyTwoBytes ChannelSigner::channel_keys_id() {
 	LDKThirtyTwoBytes ret = (self.channel_keys_id)(self.this_arg);
 	return ret;
 }
-inline LDK::CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ BaseSign::sign_counterparty_commitment(const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx, struct LDKCVec_PaymentPreimageZ preimages) {
+inline void ChannelSigner::provide_channel_parameters(const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters) {
+	(self.provide_channel_parameters)(self.this_arg, channel_parameters);
+}
+inline LDK::CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ EcdsaChannelSigner::sign_counterparty_commitment(const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx, struct LDKCVec_PaymentPreimageZ preimages) {
 	LDK::CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ ret = (self.sign_counterparty_commitment)(self.this_arg, commitment_tx, preimages);
 	return ret;
 }
-inline LDK::CResult_NoneNoneZ BaseSign::validate_counterparty_revocation(uint64_t idx, const uint8_t (*secret)[32]) {
+inline LDK::CResult_NoneNoneZ EcdsaChannelSigner::validate_counterparty_revocation(uint64_t idx, const uint8_t (*secret)[32]) {
 	LDK::CResult_NoneNoneZ ret = (self.validate_counterparty_revocation)(self.this_arg, idx, secret);
 	return ret;
 }
-inline LDK::CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ BaseSign::sign_holder_commitment_and_htlcs(const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx) {
+inline LDK::CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ EcdsaChannelSigner::sign_holder_commitment_and_htlcs(const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx) {
 	LDK::CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ ret = (self.sign_holder_commitment_and_htlcs)(self.this_arg, commitment_tx);
 	return ret;
 }
-inline LDK::CResult_SignatureNoneZ BaseSign::sign_justice_revoked_output(struct LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (*per_commitment_key)[32]) {
+inline LDK::CResult_SignatureNoneZ EcdsaChannelSigner::sign_justice_revoked_output(struct LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (*per_commitment_key)[32]) {
 	LDK::CResult_SignatureNoneZ ret = (self.sign_justice_revoked_output)(self.this_arg, justice_tx, input, amount, per_commitment_key);
 	return ret;
 }
-inline LDK::CResult_SignatureNoneZ BaseSign::sign_justice_revoked_htlc(struct LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (*per_commitment_key)[32], const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc) {
+inline LDK::CResult_SignatureNoneZ EcdsaChannelSigner::sign_justice_revoked_htlc(struct LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (*per_commitment_key)[32], const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc) {
 	LDK::CResult_SignatureNoneZ ret = (self.sign_justice_revoked_htlc)(self.this_arg, justice_tx, input, amount, per_commitment_key, htlc);
 	return ret;
 }
-inline LDK::CResult_SignatureNoneZ BaseSign::sign_counterparty_htlc_transaction(struct LDKTransaction htlc_tx, uintptr_t input, uint64_t amount, struct LDKPublicKey per_commitment_point, const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc) {
+inline LDK::CResult_SignatureNoneZ EcdsaChannelSigner::sign_counterparty_htlc_transaction(struct LDKTransaction htlc_tx, uintptr_t input, uint64_t amount, struct LDKPublicKey per_commitment_point, const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc) {
 	LDK::CResult_SignatureNoneZ ret = (self.sign_counterparty_htlc_transaction)(self.this_arg, htlc_tx, input, amount, per_commitment_point, htlc);
 	return ret;
 }
-inline LDK::CResult_SignatureNoneZ BaseSign::sign_closing_transaction(const struct LDKClosingTransaction *NONNULL_PTR closing_tx) {
+inline LDK::CResult_SignatureNoneZ EcdsaChannelSigner::sign_closing_transaction(const struct LDKClosingTransaction *NONNULL_PTR closing_tx) {
 	LDK::CResult_SignatureNoneZ ret = (self.sign_closing_transaction)(self.this_arg, closing_tx);
 	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;
-}
-inline void BaseSign::ready_channel(const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters) {
-	(self.ready_channel)(self.this_arg, channel_parameters);
-}
-inline LDK::CResult_SecretKeyNoneZ KeysInterface::get_node_secret(enum LDKRecipient recipient) {
-	LDK::CResult_SecretKeyNoneZ ret = (self.get_node_secret)(self.this_arg, recipient);
-	return ret;
-}
-inline LDK::CVec_u8Z KeysInterface::get_destination_script() {
-	LDK::CVec_u8Z ret = (self.get_destination_script)(self.this_arg);
-	return ret;
-}
-inline LDK::ShutdownScript KeysInterface::get_shutdown_scriptpubkey() {
-	LDK::ShutdownScript ret = (self.get_shutdown_scriptpubkey)(self.this_arg);
+inline LDK::CResult_SignatureNoneZ EcdsaChannelSigner::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::Sign KeysInterface::get_channel_signer(bool inbound, uint64_t channel_value_satoshis) {
-	LDK::Sign ret = (self.get_channel_signer)(self.this_arg, inbound, channel_value_satoshis);
+inline LDK::CResult_SignatureNoneZ EcdsaChannelSigner::sign_channel_announcement_with_funding_key(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg) {
+	LDK::CResult_SignatureNoneZ ret = (self.sign_channel_announcement_with_funding_key)(self.this_arg, msg);
 	return ret;
 }
-inline LDKThirtyTwoBytes KeysInterface::get_secure_random_bytes() {
+inline LDKThirtyTwoBytes EntropySource::get_secure_random_bytes() {
 	LDKThirtyTwoBytes ret = (self.get_secure_random_bytes)(self.this_arg);
 	return ret;
 }
-inline LDK::CResult_SignDecodeErrorZ KeysInterface::read_chan_signer(struct LDKu8slice reader) {
-	LDK::CResult_SignDecodeErrorZ ret = (self.read_chan_signer)(self.this_arg, reader);
+inline LDKThirtyTwoBytes NodeSigner::get_inbound_payment_key_material() {
+	LDKThirtyTwoBytes ret = (self.get_inbound_payment_key_material)(self.this_arg);
 	return ret;
 }
-inline LDK::CResult_RecoverableSignatureNoneZ KeysInterface::sign_invoice(struct LDKu8slice hrp_bytes, struct LDKCVec_u5Z invoice_data, enum LDKRecipient receipient) {
-	LDK::CResult_RecoverableSignatureNoneZ ret = (self.sign_invoice)(self.this_arg, hrp_bytes, invoice_data, receipient);
+inline LDK::CResult_PublicKeyNoneZ NodeSigner::get_node_id(enum LDKRecipient recipient) {
+	LDK::CResult_PublicKeyNoneZ ret = (self.get_node_id)(self.this_arg, recipient);
 	return ret;
 }
-inline LDKThirtyTwoBytes KeysInterface::get_inbound_payment_key_material() {
-	LDKThirtyTwoBytes ret = (self.get_inbound_payment_key_material)(self.this_arg);
+inline LDK::CResult_SharedSecretNoneZ NodeSigner::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::CResult_COption_TypeZDecodeErrorZ CustomMessageReader::read(uint16_t message_type, struct LDKu8slice buffer) {
-	LDK::CResult_COption_TypeZDecodeErrorZ ret = (self.read)(self.this_arg, message_type, buffer);
+inline LDK::CResult_RecoverableSignatureNoneZ NodeSigner::sign_invoice(struct LDKu8slice hrp_bytes, struct LDKCVec_U5Z invoice_data, enum LDKRecipient recipient) {
+	LDK::CResult_RecoverableSignatureNoneZ ret = (self.sign_invoice)(self.this_arg, hrp_bytes, invoice_data, recipient);
 	return ret;
 }
-inline uint16_t Type::type_id() {
-	uint16_t ret = (self.type_id)(self.this_arg);
+inline LDK::CResult_SignatureNoneZ NodeSigner::sign_gossip_message(struct LDKUnsignedGossipMessage msg) {
+	LDK::CResult_SignatureNoneZ ret = (self.sign_gossip_message)(self.this_arg, msg);
 	return ret;
 }
-inline LDK::Str Type::debug_str() {
-	LDK::Str ret = (self.debug_str)(self.this_arg);
+inline LDKThirtyTwoBytes SignerProvider::generate_channel_keys_id(bool inbound, uint64_t channel_value_satoshis, struct LDKU128 user_channel_id) {
+	LDKThirtyTwoBytes ret = (self.generate_channel_keys_id)(self.this_arg, inbound, channel_value_satoshis, user_channel_id);
 	return ret;
 }
-inline LDKPublicKey Payer::node_id() {
-	LDKPublicKey ret = (self.node_id)(self.this_arg);
+inline LDK::WriteableEcdsaChannelSigner SignerProvider::derive_channel_signer(uint64_t channel_value_satoshis, struct LDKThirtyTwoBytes channel_keys_id) {
+	LDK::WriteableEcdsaChannelSigner ret = (self.derive_channel_signer)(self.this_arg, channel_value_satoshis, channel_keys_id);
 	return ret;
 }
-inline LDK::CVec_ChannelDetailsZ Payer::first_hops() {
-	LDK::CVec_ChannelDetailsZ ret = (self.first_hops)(self.this_arg);
+inline LDK::CResult_WriteableEcdsaChannelSignerDecodeErrorZ SignerProvider::read_chan_signer(struct LDKu8slice reader) {
+	LDK::CResult_WriteableEcdsaChannelSignerDecodeErrorZ ret = (self.read_chan_signer)(self.this_arg, reader);
 	return ret;
 }
-inline LDK::CResult_PaymentIdPaymentSendFailureZ Payer::send_payment(const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_hash, struct LDKThirtyTwoBytes payment_secret) {
-	LDK::CResult_PaymentIdPaymentSendFailureZ ret = (self.send_payment)(self.this_arg, route, payment_hash, payment_secret);
+inline LDK::CVec_u8Z SignerProvider::get_destination_script() {
+	LDK::CVec_u8Z ret = (self.get_destination_script)(self.this_arg);
 	return ret;
 }
-inline LDK::CResult_PaymentIdPaymentSendFailureZ Payer::send_spontaneous_payment(const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_preimage) {
-	LDK::CResult_PaymentIdPaymentSendFailureZ ret = (self.send_spontaneous_payment)(self.this_arg, route, payment_preimage);
+inline LDK::ShutdownScript SignerProvider::get_shutdown_scriptpubkey() {
+	LDK::ShutdownScript ret = (self.get_shutdown_scriptpubkey)(self.this_arg);
 	return ret;
 }
-inline LDK::CResult_NonePaymentSendFailureZ Payer::retry_payment(const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_id) {
-	LDK::CResult_NonePaymentSendFailureZ ret = (self.retry_payment)(self.this_arg, route, payment_id);
+inline LDK::CResult_COption_TypeZDecodeErrorZ CustomMessageReader::read(uint16_t message_type, struct LDKu8slice buffer) {
+	LDK::CResult_COption_TypeZDecodeErrorZ ret = (self.read)(self.this_arg, message_type, buffer);
 	return ret;
 }
-inline void Payer::abandon_payment(struct LDKThirtyTwoBytes payment_id) {
-	(self.abandon_payment)(self.this_arg, payment_id);
+inline uint16_t Type::type_id() {
+	uint16_t ret = (self.type_id)(self.this_arg);
+	return ret;
 }
-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::Str Type::debug_str() {
+	LDK::Str ret = (self.debug_str)(self.this_arg);
 	return ret;
 }
 inline LDK::CResult_NoneLightningErrorZ CustomMessageHandler::handle_custom_message(struct LDKType msg, struct LDKPublicKey sender_node_id) {
@@ -7273,6 +8357,17 @@ inline uint64_t SocketDescriptor::hash() {
 	uint64_t ret = (self.hash)(self.this_arg);
 	return ret;
 }
+inline LDK::UtxoResult UtxoLookup::get_utxo(const uint8_t (*genesis_hash)[32], uint64_t short_channel_id) {
+	LDK::UtxoResult ret = (self.get_utxo)(self.this_arg, genesis_hash, short_channel_id);
+	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,15 +8376,15 @@ 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;
 }
-inline void ChannelMessageHandler::handle_open_channel(struct LDKPublicKey their_node_id, struct LDKInitFeatures their_features, const struct LDKOpenChannel *NONNULL_PTR msg) {
-	(self.handle_open_channel)(self.this_arg, their_node_id, their_features, msg);
+inline void ChannelMessageHandler::handle_open_channel(struct LDKPublicKey their_node_id, const struct LDKOpenChannel *NONNULL_PTR msg) {
+	(self.handle_open_channel)(self.this_arg, their_node_id, msg);
 }
-inline void ChannelMessageHandler::handle_accept_channel(struct LDKPublicKey their_node_id, struct LDKInitFeatures their_features, const struct LDKAcceptChannel *NONNULL_PTR msg) {
-	(self.handle_accept_channel)(self.this_arg, their_node_id, their_features, msg);
+inline void ChannelMessageHandler::handle_accept_channel(struct LDKPublicKey their_node_id, const struct LDKAcceptChannel *NONNULL_PTR msg) {
+	(self.handle_accept_channel)(self.this_arg, their_node_id, msg);
 }
 inline void ChannelMessageHandler::handle_funding_created(struct LDKPublicKey their_node_id, const struct LDKFundingCreated *NONNULL_PTR msg) {
 	(self.handle_funding_created)(self.this_arg, their_node_id, msg);
@@ -7300,8 +8395,8 @@ inline void ChannelMessageHandler::handle_funding_signed(struct LDKPublicKey the
 inline void ChannelMessageHandler::handle_channel_ready(struct LDKPublicKey their_node_id, const struct LDKChannelReady *NONNULL_PTR msg) {
 	(self.handle_channel_ready)(self.this_arg, their_node_id, msg);
 }
-inline void ChannelMessageHandler::handle_shutdown(struct LDKPublicKey their_node_id, const struct LDKInitFeatures *NONNULL_PTR their_features, const struct LDKShutdown *NONNULL_PTR msg) {
-	(self.handle_shutdown)(self.this_arg, their_node_id, their_features, msg);
+inline void ChannelMessageHandler::handle_shutdown(struct LDKPublicKey their_node_id, const struct LDKShutdown *NONNULL_PTR msg) {
+	(self.handle_shutdown)(self.this_arg, their_node_id, msg);
 }
 inline void ChannelMessageHandler::handle_closing_signed(struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg) {
 	(self.handle_closing_signed)(self.this_arg, their_node_id, msg);
@@ -7330,11 +8425,12 @@ inline void ChannelMessageHandler::handle_update_fee(struct LDKPublicKey their_n
 inline void ChannelMessageHandler::handle_announcement_signatures(struct LDKPublicKey their_node_id, const struct LDKAnnouncementSignatures *NONNULL_PTR msg) {
 	(self.handle_announcement_signatures)(self.this_arg, their_node_id, msg);
 }
-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_disconnected(struct LDKPublicKey their_node_id) {
+	(self.peer_disconnected)(self.this_arg, their_node_id);
 }
-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, bool inbound) {
+	LDK::CResult_NoneNoneZ ret = (self.peer_connected)(self.this_arg, their_node_id, msg, inbound);
+	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 +8441,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 +8461,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 LDKNodeId 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, bool inbound) {
+	LDK::CResult_NoneNoneZ ret = (self.peer_connected)(self.this_arg, their_node_id, init, inbound);
+	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 +8489,48 @@ 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 bool RoutingMessageHandler::processing_queue_high() {
+	bool ret = (self.processing_queue_high)(self.this_arg);
+	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, bool inbound) {
+	LDK::CResult_NoneNoneZ ret = (self.peer_connected)(self.this_arg, their_node_id, init, inbound);
+	return ret;
+}
+inline void OnionMessageHandler::peer_disconnected(struct LDKPublicKey their_node_id) {
+	(self.peer_disconnected)(self.this_arg, their_node_id);
+}
+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, struct LDKChannelMonitorUpdate 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;
 }
 }