X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;ds=sidebyside;f=lightning-c-bindings%2Finclude%2Flightningpp.hpp;fp=lightning-c-bindings%2Finclude%2Flightningpp.hpp;h=c4ef0ea71820765cf20cbe3b442405b8c42c0d8b;hb=82601052fe2cac04a6249f5930495e987923303b;hp=c9e30a33a1261ed195b9831f532a254dd27a4ffa;hpb=730426d42bee06abf4047fe3592af45844e74d10;p=ldk-c-bindings

diff --git a/lightning-c-bindings/include/lightningpp.hpp b/lightning-c-bindings/include/lightningpp.hpp
index c9e30a3..c4ef0ea 100644
--- a/lightning-c-bindings/include/lightningpp.hpp
+++ b/lightning-c-bindings/include/lightningpp.hpp
@@ -2,9 +2,11 @@
 namespace LDK {
 // Forward declarations
 class Str;
+class Refund;
 class Retry;
 class RetryableSendFailure;
 class PaymentSendFailure;
+class RecipientOnionFields;
 class HTLCClaim;
 class CounterpartyCommitmentSecrets;
 class TxCreationKeys;
@@ -21,8 +23,8 @@ class CommitmentTransaction;
 class TrustedCommitmentTransaction;
 class ShutdownScript;
 class InvalidShutdownScript;
-class BlindedPath;
-class BlindedHop;
+class UnsignedInvoice;
+class BlindedPayInfo;
 class BackgroundProcessor;
 class GossipSync;
 class DefaultRouter;
@@ -30,24 +32,17 @@ class Router;
 class ScorerAccountingForInFlightHtlcs;
 class InFlightHtlcs;
 class RouteHop;
+class BlindedTail;
+class Path;
 class Route;
 class RouteParameters;
 class PaymentParameters;
+class Hints;
 class RouteHint;
 class RouteHintHop;
 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 Listen;
 class Confirm;
@@ -64,6 +59,8 @@ class ChannelUsage;
 class FixedPenaltyScorer;
 class ProbabilisticScorer;
 class ProbabilisticScoringParameters;
+class OnionMessageContents;
+class CustomOnionMessageContents;
 class InitFeatures;
 class NodeFeatures;
 class ChannelFeatures;
@@ -73,8 +70,20 @@ class InvoiceRequestFeatures;
 class Bolt12InvoiceFeatures;
 class BlindedHopFeatures;
 class ChannelTypeFeatures;
-class OnionMessageContents;
-class CustomOnionMessageContents;
+class PaymentPurpose;
+class PathFailure;
+class ClosureReason;
+class HTLCDestination;
+class PaymentFailureReason;
+class Event;
+class MessageSendEvent;
+class MessageSendEventsProvider;
+class OnionMessageProvider;
+class EventsProvider;
+class EventHandler;
+class Offer;
+class Amount;
+class Quantity;
 class NodeId;
 class NetworkGraph;
 class ReadOnlyNetworkGraph;
@@ -118,6 +127,7 @@ class UserConfig;
 class APIError;
 class BigSize;
 class Hostname;
+class UntrustedString;
 class PrintableString;
 class OutPoint;
 class CustomMessageReader;
@@ -144,6 +154,8 @@ class OnionMessenger;
 class Destination;
 class SendError;
 class CustomOnionMessageHandler;
+class BlindedPath;
+class BlindedHop;
 class ParseError;
 class ParseOrSemanticError;
 class Invoice;
@@ -164,7 +176,6 @@ class PrivateRoute;
 class CreationError;
 class SemanticError;
 class SignOrCreationError;
-class RapidGossipSync;
 class Persister;
 class DecodeError;
 class Init;
@@ -210,17 +221,22 @@ class CommitmentUpdate;
 class ChannelMessageHandler;
 class RoutingMessageHandler;
 class OnionMessageHandler;
-class GraphSyncError;
+class UnsignedInvoiceRequest;
+class InvoiceRequest;
 class Level;
 class Record;
 class Logger;
 class FutureCallback;
 class Future;
+class Sleeper;
 class MonitorUpdateId;
 class Persist;
 class LockedChannelMonitor;
 class ChainMonitor;
+class GraphSyncError;
+class RapidGossipSync;
 class CResult_LockedChannelMonitorNoneZ;
+class CVec_C2Tuple_BlindedPayInfoBlindedPathZZ;
 class CResult_PhantomRouteHintsDecodeErrorZ;
 class CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ;
 class CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ;
@@ -245,6 +261,7 @@ class CVec_C2Tuple_TxidBlockHashZZ;
 class CResult_CommitmentTransactionDecodeErrorZ;
 class CResult_TransactionNoneZ;
 class CResult_ClosingSignedFeeRangeDecodeErrorZ;
+class COption_DurationZ;
 class CResult_ErrorMessageDecodeErrorZ;
 class CResult_OpenChannelDecodeErrorZ;
 class COption_APIErrorZ;
@@ -277,6 +294,7 @@ class CResult_CounterpartyCommitmentSecretsDecodeErrorZ;
 class CVec_RecentPaymentDetailsZ;
 class CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ;
 class CVec_RouteHintHopZ;
+class CResult_UntrustedStringDecodeErrorZ;
 class CResult_PaymentParametersDecodeErrorZ;
 class CVec_U5Z;
 class COption_UtxoLookupZ;
@@ -297,17 +315,19 @@ class CResult_SiPrefixParseErrorZ;
 class CResult_BlindedHopDecodeErrorZ;
 class CResult_TrustedCommitmentTransactionNoneZ;
 class CResult_FixedPenaltyScorerDecodeErrorZ;
+class CVec_BlindedPathZ;
 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_PaymentFailureReasonDecodeErrorZ;
+class C2Tuple_PublicKeyCOption_NetAddressZZ;
 class CResult__u832APIErrorZ;
 class CResult_PaymentIdPaymentErrorZ;
 class CResult_COption_MonitorEventZDecodeErrorZ;
 class CResult_RoutingFeesDecodeErrorZ;
+class CResult_NonePeerHandleErrorZ;
 class CResult_PayeePubKeyErrorZ;
 class CResult_DescriptionCreationErrorZ;
 class CResult_QueryShortChannelIdsDecodeErrorZ;
@@ -325,6 +345,7 @@ class CResult_UnsignedChannelUpdateDecodeErrorZ;
 class CVec_EventZ;
 class CResult_NoneSemanticErrorZ;
 class CVec_C2Tuple_u32ScriptZZ;
+class CVec_BlindedHopZ;
 class CResult_COption_ClosureReasonZDecodeErrorZ;
 class CResult_PaymentHashPaymentSendFailureZ;
 class C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ;
@@ -354,15 +375,16 @@ class COption_WriteableScoreZ;
 class CResult_PositiveTimestampCreationErrorZ;
 class C2Tuple__u168_u168Z;
 class CResult_InvoiceFeaturesDecodeErrorZ;
+class C2Tuple_BlindedPayInfoBlindedPathZ;
 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_InvoiceSignOrCreationErrorZ;
 class CResult_InitFeaturesDecodeErrorZ;
 class CResult_PublicKeyNoneZ;
 class CResult_PingDecodeErrorZ;
@@ -373,23 +395,25 @@ class CVec_CVec_u8ZZ;
 class CResult_COption_CustomOnionMessageContentsZDecodeErrorZ;
 class CResult_ShutdownScriptDecodeErrorZ;
 class CResult_ProbabilisticScorerDecodeErrorZ;
-class CResult_TxCreationKeysDecodeErrorZ;
 class C2Tuple_usizeTransactionZ;
+class CResult_TxCreationKeysDecodeErrorZ;
 class CResult_NodeAnnouncementDecodeErrorZ;
-class CResult_BlindedPathDecodeErrorZ;
 class CVec_ChannelMonitorZ;
+class CResult_BlindedPathDecodeErrorZ;
+class CVec_FutureZ;
 class CResult_RouteHopDecodeErrorZ;
 class CVec_BalanceZ;
 class CResult_FundingSignedDecodeErrorZ;
 class CResult_RecoverableSignatureNoneZ;
 class C2Tuple_Z;
 class C3Tuple_RawInvoice_u832InvoiceSignatureZ;
+class CVec_PathZ;
 class CResult_NetworkGraphDecodeErrorZ;
 class CResult_NodeInfoDecodeErrorZ;
 class CVec_NodeIdZ;
-class CResult_RouteLightningErrorZ;
-class CResult_ChannelPublicKeysDecodeErrorZ;
 class CVec_u8Z;
+class CResult_ChannelPublicKeysDecodeErrorZ;
+class CResult_RouteLightningErrorZ;
 class CResult_NonePaymentSendFailureZ;
 class CResult_HolderCommitmentTransactionDecodeErrorZ;
 class CResult_WarningMessageDecodeErrorZ;
@@ -406,6 +430,7 @@ class COption_NetAddressZ;
 class C2Tuple_OutPointScriptZ;
 class CResult_RouteHintHopDecodeErrorZ;
 class CResult_UpdateFailMalformedHTLCDecodeErrorZ;
+class CResult_BlindedPayInfoDecodeErrorZ;
 class CResult_SharedSecretNoneZ;
 class CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ;
 class CResult_CVec_CVec_u8ZZNoneZ;
@@ -419,8 +444,10 @@ class CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ;
 class COption_EventZ;
 class CResult_ChannelTypeFeaturesDecodeErrorZ;
 class CVec_RouteHintZ;
+class COption_PaymentFailureReasonZ;
 class COption_u16Z;
-class CVec_CVec_RouteHopZZ;
+class CVec_ChainHashZ;
+class CResult_BlindedTailDecodeErrorZ;
 class CVec_C2Tuple_PublicKeyTypeZZ;
 class C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ;
 class CResult_u32GraphSyncErrorZ;
@@ -429,9 +456,10 @@ class CResult_NoneAPIErrorZ;
 class CResult_CounterpartyChannelTransactionParametersDecodeErrorZ;
 class CVec_NetAddressZ;
 class CResult_ChannelDetailsDecodeErrorZ;
-class CVec_PublicKeyZ;
 class CVec_C2Tuple_usizeTransactionZZ;
+class CVec_PublicKeyZ;
 class C2Tuple_u64u64Z;
+class CResult_RecipientOnionFieldsDecodeErrorZ;
 class C2Tuple_u32TxOutZ;
 class CResult_PaymentSecretNoneZ;
 class CResult_ChannelConfigDecodeErrorZ;
@@ -448,6 +476,7 @@ class COption_ClosureReasonZ;
 class COption_u128Z;
 class CVec_APIErrorZ;
 class CResult_boolPeerHandleErrorZ;
+class CVec_AddressZ;
 class CResult_ChannelUpdateDecodeErrorZ;
 class CResult_PaymentSecretAPIErrorZ;
 class CResult_CounterpartyForwardingInfoDecodeErrorZ;
@@ -456,6 +485,7 @@ class CResult_SignedRawInvoiceParseErrorZ;
 class COption_C2Tuple_EightU16sEightU16sZZ;
 class CResult_RouteDecodeErrorZ;
 class COption_NoneZ;
+class COption_CVec_u8ZZ;
 
 class Str {
 private:
@@ -472,6 +502,21 @@ public:
 	const LDKStr* operator &() const { return &self; }
 	const LDKStr* operator ->() const { return &self; }
 };
+class Refund {
+private:
+	LDKRefund self;
+public:
+	Refund(const Refund&) = delete;
+	Refund(Refund&& o) : self(o.self) { memset(&o, 0, sizeof(Refund)); }
+	Refund(LDKRefund&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRefund)); }
+	operator LDKRefund() && { LDKRefund res = self; memset(&self, 0, sizeof(LDKRefund)); return res; }
+	~Refund() { Refund_free(self); }
+	Refund& operator=(Refund&& o) { Refund_free(self); self = o.self; memset(&o, 0, sizeof(Refund)); return *this; }
+	LDKRefund* operator &() { return &self; }
+	LDKRefund* operator ->() { return &self; }
+	const LDKRefund* operator &() const { return &self; }
+	const LDKRefund* operator ->() const { return &self; }
+};
 class Retry {
 private:
 	LDKRetry self;
@@ -516,6 +561,21 @@ public:
 	const LDKPaymentSendFailure* operator &() const { return &self; }
 	const LDKPaymentSendFailure* operator ->() const { return &self; }
 };
+class RecipientOnionFields {
+private:
+	LDKRecipientOnionFields self;
+public:
+	RecipientOnionFields(const RecipientOnionFields&) = delete;
+	RecipientOnionFields(RecipientOnionFields&& o) : self(o.self) { memset(&o, 0, sizeof(RecipientOnionFields)); }
+	RecipientOnionFields(LDKRecipientOnionFields&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRecipientOnionFields)); }
+	operator LDKRecipientOnionFields() && { LDKRecipientOnionFields res = self; memset(&self, 0, sizeof(LDKRecipientOnionFields)); return res; }
+	~RecipientOnionFields() { RecipientOnionFields_free(self); }
+	RecipientOnionFields& operator=(RecipientOnionFields&& o) { RecipientOnionFields_free(self); self = o.self; memset(&o, 0, sizeof(RecipientOnionFields)); return *this; }
+	LDKRecipientOnionFields* operator &() { return &self; }
+	LDKRecipientOnionFields* operator ->() { return &self; }
+	const LDKRecipientOnionFields* operator &() const { return &self; }
+	const LDKRecipientOnionFields* operator ->() const { return &self; }
+};
 class HTLCClaim {
 private:
 	LDKHTLCClaim self;
@@ -755,35 +815,35 @@ public:
 	const LDKInvalidShutdownScript* operator &() const { return &self; }
 	const LDKInvalidShutdownScript* operator ->() const { return &self; }
 };
-class BlindedPath {
+class UnsignedInvoice {
 private:
-	LDKBlindedPath self;
+	LDKUnsignedInvoice 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; }
+	UnsignedInvoice(const UnsignedInvoice&) = delete;
+	UnsignedInvoice(UnsignedInvoice&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedInvoice)); }
+	UnsignedInvoice(LDKUnsignedInvoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedInvoice)); }
+	operator LDKUnsignedInvoice() && { LDKUnsignedInvoice res = self; memset(&self, 0, sizeof(LDKUnsignedInvoice)); return res; }
+	~UnsignedInvoice() { UnsignedInvoice_free(self); }
+	UnsignedInvoice& operator=(UnsignedInvoice&& o) { UnsignedInvoice_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedInvoice)); return *this; }
+	LDKUnsignedInvoice* operator &() { return &self; }
+	LDKUnsignedInvoice* operator ->() { return &self; }
+	const LDKUnsignedInvoice* operator &() const { return &self; }
+	const LDKUnsignedInvoice* operator ->() const { return &self; }
 };
-class BlindedHop {
+class BlindedPayInfo {
 private:
-	LDKBlindedHop self;
+	LDKBlindedPayInfo 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; }
+	BlindedPayInfo(const BlindedPayInfo&) = delete;
+	BlindedPayInfo(BlindedPayInfo&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedPayInfo)); }
+	BlindedPayInfo(LDKBlindedPayInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedPayInfo)); }
+	operator LDKBlindedPayInfo() && { LDKBlindedPayInfo res = self; memset(&self, 0, sizeof(LDKBlindedPayInfo)); return res; }
+	~BlindedPayInfo() { BlindedPayInfo_free(self); }
+	BlindedPayInfo& operator=(BlindedPayInfo&& o) { BlindedPayInfo_free(self); self = o.self; memset(&o, 0, sizeof(BlindedPayInfo)); return *this; }
+	LDKBlindedPayInfo* operator &() { return &self; }
+	LDKBlindedPayInfo* operator ->() { return &self; }
+	const LDKBlindedPayInfo* operator &() const { return &self; }
+	const LDKBlindedPayInfo* operator ->() const { return &self; }
 };
 class BackgroundProcessor {
 private:
@@ -903,6 +963,36 @@ public:
 	const LDKRouteHop* operator &() const { return &self; }
 	const LDKRouteHop* operator ->() const { return &self; }
 };
+class BlindedTail {
+private:
+	LDKBlindedTail self;
+public:
+	BlindedTail(const BlindedTail&) = delete;
+	BlindedTail(BlindedTail&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedTail)); }
+	BlindedTail(LDKBlindedTail&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedTail)); }
+	operator LDKBlindedTail() && { LDKBlindedTail res = self; memset(&self, 0, sizeof(LDKBlindedTail)); return res; }
+	~BlindedTail() { BlindedTail_free(self); }
+	BlindedTail& operator=(BlindedTail&& o) { BlindedTail_free(self); self = o.self; memset(&o, 0, sizeof(BlindedTail)); return *this; }
+	LDKBlindedTail* operator &() { return &self; }
+	LDKBlindedTail* operator ->() { return &self; }
+	const LDKBlindedTail* operator &() const { return &self; }
+	const LDKBlindedTail* operator ->() const { return &self; }
+};
+class Path {
+private:
+	LDKPath self;
+public:
+	Path(const Path&) = delete;
+	Path(Path&& o) : self(o.self) { memset(&o, 0, sizeof(Path)); }
+	Path(LDKPath&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPath)); }
+	operator LDKPath() && { LDKPath res = self; memset(&self, 0, sizeof(LDKPath)); return res; }
+	~Path() { Path_free(self); }
+	Path& operator=(Path&& o) { Path_free(self); self = o.self; memset(&o, 0, sizeof(Path)); return *this; }
+	LDKPath* operator &() { return &self; }
+	LDKPath* operator ->() { return &self; }
+	const LDKPath* operator &() const { return &self; }
+	const LDKPath* operator ->() const { return &self; }
+};
 class Route {
 private:
 	LDKRoute self;
@@ -948,6 +1038,21 @@ public:
 	const LDKPaymentParameters* operator &() const { return &self; }
 	const LDKPaymentParameters* operator ->() const { return &self; }
 };
+class Hints {
+private:
+	LDKHints self;
+public:
+	Hints(const Hints&) = delete;
+	Hints(Hints&& o) : self(o.self) { memset(&o, 0, sizeof(Hints)); }
+	Hints(LDKHints&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHints)); }
+	operator LDKHints() && { LDKHints res = self; memset(&self, 0, sizeof(LDKHints)); return res; }
+	~Hints() { Hints_free(self); }
+	Hints& operator=(Hints&& o) { Hints_free(self); self = o.self; memset(&o, 0, sizeof(Hints)); return *this; }
+	LDKHints* operator &() { return &self; }
+	LDKHints* operator ->() { return &self; }
+	const LDKHints* operator &() const { return &self; }
+	const LDKHints* operator ->() const { return &self; }
+};
 class RouteHint {
 private:
 	LDKRouteHint self;
@@ -1037,179 +1142,6 @@ public:
 	 */
 	inline uint32_t get_est_sat_per_1000_weight(enum LDKConfirmationTarget confirmation_target);
 };
-class PaymentPurpose {
-private:
-	LDKPaymentPurpose self;
-public:
-	PaymentPurpose(const PaymentPurpose&) = delete;
-	PaymentPurpose(PaymentPurpose&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentPurpose)); }
-	PaymentPurpose(LDKPaymentPurpose&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentPurpose)); }
-	operator LDKPaymentPurpose() && { LDKPaymentPurpose res = self; memset(&self, 0, sizeof(LDKPaymentPurpose)); return res; }
-	~PaymentPurpose() { PaymentPurpose_free(self); }
-	PaymentPurpose& operator=(PaymentPurpose&& o) { PaymentPurpose_free(self); self = o.self; memset(&o, 0, sizeof(PaymentPurpose)); return *this; }
-	LDKPaymentPurpose* operator &() { return &self; }
-	LDKPaymentPurpose* operator ->() { return &self; }
-	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;
-public:
-	ClosureReason(const ClosureReason&) = delete;
-	ClosureReason(ClosureReason&& o) : self(o.self) { memset(&o, 0, sizeof(ClosureReason)); }
-	ClosureReason(LDKClosureReason&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClosureReason)); }
-	operator LDKClosureReason() && { LDKClosureReason res = self; memset(&self, 0, sizeof(LDKClosureReason)); return res; }
-	~ClosureReason() { ClosureReason_free(self); }
-	ClosureReason& operator=(ClosureReason&& o) { ClosureReason_free(self); self = o.self; memset(&o, 0, sizeof(ClosureReason)); return *this; }
-	LDKClosureReason* operator &() { return &self; }
-	LDKClosureReason* operator ->() { return &self; }
-	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;
-public:
-	Event(const Event&) = delete;
-	Event(Event&& o) : self(o.self) { memset(&o, 0, sizeof(Event)); }
-	Event(LDKEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEvent)); }
-	operator LDKEvent() && { LDKEvent res = self; memset(&self, 0, sizeof(LDKEvent)); return res; }
-	~Event() { Event_free(self); }
-	Event& operator=(Event&& o) { Event_free(self); self = o.self; memset(&o, 0, sizeof(Event)); return *this; }
-	LDKEvent* operator &() { return &self; }
-	LDKEvent* operator ->() { return &self; }
-	const LDKEvent* operator &() const { return &self; }
-	const LDKEvent* operator ->() const { return &self; }
-};
-class MessageSendEvent {
-private:
-	LDKMessageSendEvent self;
-public:
-	MessageSendEvent(const MessageSendEvent&) = delete;
-	MessageSendEvent(MessageSendEvent&& o) : self(o.self) { memset(&o, 0, sizeof(MessageSendEvent)); }
-	MessageSendEvent(LDKMessageSendEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageSendEvent)); }
-	operator LDKMessageSendEvent() && { LDKMessageSendEvent res = self; memset(&self, 0, sizeof(LDKMessageSendEvent)); return res; }
-	~MessageSendEvent() { MessageSendEvent_free(self); }
-	MessageSendEvent& operator=(MessageSendEvent&& o) { MessageSendEvent_free(self); self = o.self; memset(&o, 0, sizeof(MessageSendEvent)); return *this; }
-	LDKMessageSendEvent* operator &() { return &self; }
-	LDKMessageSendEvent* operator ->() { return &self; }
-	const LDKMessageSendEvent* operator &() const { return &self; }
-	const LDKMessageSendEvent* operator ->() const { return &self; }
-};
-class MessageSendEventsProvider {
-private:
-	LDKMessageSendEventsProvider self;
-public:
-	MessageSendEventsProvider(const MessageSendEventsProvider&) = delete;
-	MessageSendEventsProvider(MessageSendEventsProvider&& o) : self(o.self) { memset(&o, 0, sizeof(MessageSendEventsProvider)); }
-	MessageSendEventsProvider(LDKMessageSendEventsProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageSendEventsProvider)); }
-	operator LDKMessageSendEventsProvider() && { LDKMessageSendEventsProvider res = self; memset(&self, 0, sizeof(LDKMessageSendEventsProvider)); return res; }
-	~MessageSendEventsProvider() { MessageSendEventsProvider_free(self); }
-	MessageSendEventsProvider& operator=(MessageSendEventsProvider&& o) { MessageSendEventsProvider_free(self); self = o.self; memset(&o, 0, sizeof(MessageSendEventsProvider)); return *this; }
-	LDKMessageSendEventsProvider* operator &() { return &self; }
-	LDKMessageSendEventsProvider* operator ->() { return &self; }
-	const LDKMessageSendEventsProvider* operator &() const { return &self; }
-	const LDKMessageSendEventsProvider* operator ->() const { return &self; }
-	/**
-	 *  Gets the list of pending events which were generated by previous actions, clearing the list
-	 *  in the process.
-	 */
-	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;
-public:
-	EventsProvider(const EventsProvider&) = delete;
-	EventsProvider(EventsProvider&& o) : self(o.self) { memset(&o, 0, sizeof(EventsProvider)); }
-	EventsProvider(LDKEventsProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEventsProvider)); }
-	operator LDKEventsProvider() && { LDKEventsProvider res = self; memset(&self, 0, sizeof(LDKEventsProvider)); return res; }
-	~EventsProvider() { EventsProvider_free(self); }
-	EventsProvider& operator=(EventsProvider&& o) { EventsProvider_free(self); self = o.self; memset(&o, 0, sizeof(EventsProvider)); return *this; }
-	LDKEventsProvider* operator &() { return &self; }
-	LDKEventsProvider* operator ->() { return &self; }
-	const LDKEventsProvider* operator &() const { return &self; }
-	const LDKEventsProvider* operator ->() const { return &self; }
-	/**
-	 *  Processes any events generated since the last call using the given event handler.
-	 * 
-	 *  See the trait-level documentation for requirements.
-	 */
-	inline void process_pending_events(struct LDKEventHandler handler);
-};
-class EventHandler {
-private:
-	LDKEventHandler self;
-public:
-	EventHandler(const EventHandler&) = delete;
-	EventHandler(EventHandler&& o) : self(o.self) { memset(&o, 0, sizeof(EventHandler)); }
-	EventHandler(LDKEventHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEventHandler)); }
-	operator LDKEventHandler() && { LDKEventHandler res = self; memset(&self, 0, sizeof(LDKEventHandler)); return res; }
-	~EventHandler() { EventHandler_free(self); }
-	EventHandler& operator=(EventHandler&& o) { EventHandler_free(self); self = o.self; memset(&o, 0, sizeof(EventHandler)); return *this; }
-	LDKEventHandler* operator &() { return &self; }
-	LDKEventHandler* operator ->() { return &self; }
-	const LDKEventHandler* operator &() const { return &self; }
-	const LDKEventHandler* operator ->() const { return &self; }
-	/**
-	 *  Handles the given [`Event`].
-	 * 
-	 *  See [`EventsProvider`] for details that must be considered when implementing this method.
-	 */
-	inline void handle_event(struct LDKEvent event);
-};
 class BestBlock {
 private:
 	LDKBestBlock self;
@@ -1464,19 +1396,19 @@ public:
 	/**
 	 *  Handles updating channel penalties after failing to route through a channel.
 	 */
-	inline void payment_path_failed(struct LDKCVec_RouteHopZ path, uint64_t short_channel_id);
+	inline void payment_path_failed(const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id);
 	/**
 	 *  Handles updating channel penalties after successfully routing along a path.
 	 */
-	inline void payment_path_successful(struct LDKCVec_RouteHopZ path);
+	inline void payment_path_successful(const struct LDKPath *NONNULL_PTR 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);
+	inline void probe_failed(const struct LDKPath *NONNULL_PTR 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);
+	inline void probe_successful(const struct LDKPath *NONNULL_PTR path);
 };
 class LockableScore {
 private:
@@ -1602,6 +1534,40 @@ public:
 	const LDKProbabilisticScoringParameters* operator &() const { return &self; }
 	const LDKProbabilisticScoringParameters* 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 InitFeatures {
 private:
 	LDKInitFeatures self;
@@ -1707,69 +1673,267 @@ public:
 	const LDKBolt12InvoiceFeatures* operator &() const { return &self; }
 	const LDKBolt12InvoiceFeatures* operator ->() const { return &self; }
 };
-class BlindedHopFeatures {
+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;
+public:
+	ChannelTypeFeatures(const ChannelTypeFeatures&) = delete;
+	ChannelTypeFeatures(ChannelTypeFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelTypeFeatures)); }
+	ChannelTypeFeatures(LDKChannelTypeFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelTypeFeatures)); }
+	operator LDKChannelTypeFeatures() && { LDKChannelTypeFeatures res = self; memset(&self, 0, sizeof(LDKChannelTypeFeatures)); return res; }
+	~ChannelTypeFeatures() { ChannelTypeFeatures_free(self); }
+	ChannelTypeFeatures& operator=(ChannelTypeFeatures&& o) { ChannelTypeFeatures_free(self); self = o.self; memset(&o, 0, sizeof(ChannelTypeFeatures)); return *this; }
+	LDKChannelTypeFeatures* operator &() { return &self; }
+	LDKChannelTypeFeatures* operator ->() { return &self; }
+	const LDKChannelTypeFeatures* operator &() const { return &self; }
+	const LDKChannelTypeFeatures* operator ->() const { return &self; }
+};
+class PaymentPurpose {
+private:
+	LDKPaymentPurpose self;
+public:
+	PaymentPurpose(const PaymentPurpose&) = delete;
+	PaymentPurpose(PaymentPurpose&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentPurpose)); }
+	PaymentPurpose(LDKPaymentPurpose&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentPurpose)); }
+	operator LDKPaymentPurpose() && { LDKPaymentPurpose res = self; memset(&self, 0, sizeof(LDKPaymentPurpose)); return res; }
+	~PaymentPurpose() { PaymentPurpose_free(self); }
+	PaymentPurpose& operator=(PaymentPurpose&& o) { PaymentPurpose_free(self); self = o.self; memset(&o, 0, sizeof(PaymentPurpose)); return *this; }
+	LDKPaymentPurpose* operator &() { return &self; }
+	LDKPaymentPurpose* operator ->() { return &self; }
+	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;
+public:
+	ClosureReason(const ClosureReason&) = delete;
+	ClosureReason(ClosureReason&& o) : self(o.self) { memset(&o, 0, sizeof(ClosureReason)); }
+	ClosureReason(LDKClosureReason&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClosureReason)); }
+	operator LDKClosureReason() && { LDKClosureReason res = self; memset(&self, 0, sizeof(LDKClosureReason)); return res; }
+	~ClosureReason() { ClosureReason_free(self); }
+	ClosureReason& operator=(ClosureReason&& o) { ClosureReason_free(self); self = o.self; memset(&o, 0, sizeof(ClosureReason)); return *this; }
+	LDKClosureReason* operator &() { return &self; }
+	LDKClosureReason* operator ->() { return &self; }
+	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 PaymentFailureReason {
+private:
+	LDKPaymentFailureReason self;
+public:
+	PaymentFailureReason(const PaymentFailureReason&) = delete;
+	PaymentFailureReason(PaymentFailureReason&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentFailureReason)); }
+	PaymentFailureReason(LDKPaymentFailureReason&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentFailureReason)); }
+	operator LDKPaymentFailureReason() && { LDKPaymentFailureReason res = self; memset(&self, 0, sizeof(LDKPaymentFailureReason)); return res; }
+	PaymentFailureReason& operator=(PaymentFailureReason&& o) { self = o.self; memset(&o, 0, sizeof(PaymentFailureReason)); return *this; }
+	LDKPaymentFailureReason* operator &() { return &self; }
+	LDKPaymentFailureReason* operator ->() { return &self; }
+	const LDKPaymentFailureReason* operator &() const { return &self; }
+	const LDKPaymentFailureReason* operator ->() const { return &self; }
+};
+class Event {
+private:
+	LDKEvent self;
+public:
+	Event(const Event&) = delete;
+	Event(Event&& o) : self(o.self) { memset(&o, 0, sizeof(Event)); }
+	Event(LDKEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEvent)); }
+	operator LDKEvent() && { LDKEvent res = self; memset(&self, 0, sizeof(LDKEvent)); return res; }
+	~Event() { Event_free(self); }
+	Event& operator=(Event&& o) { Event_free(self); self = o.self; memset(&o, 0, sizeof(Event)); return *this; }
+	LDKEvent* operator &() { return &self; }
+	LDKEvent* operator ->() { return &self; }
+	const LDKEvent* operator &() const { return &self; }
+	const LDKEvent* operator ->() const { return &self; }
+};
+class MessageSendEvent {
+private:
+	LDKMessageSendEvent self;
+public:
+	MessageSendEvent(const MessageSendEvent&) = delete;
+	MessageSendEvent(MessageSendEvent&& o) : self(o.self) { memset(&o, 0, sizeof(MessageSendEvent)); }
+	MessageSendEvent(LDKMessageSendEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageSendEvent)); }
+	operator LDKMessageSendEvent() && { LDKMessageSendEvent res = self; memset(&self, 0, sizeof(LDKMessageSendEvent)); return res; }
+	~MessageSendEvent() { MessageSendEvent_free(self); }
+	MessageSendEvent& operator=(MessageSendEvent&& o) { MessageSendEvent_free(self); self = o.self; memset(&o, 0, sizeof(MessageSendEvent)); return *this; }
+	LDKMessageSendEvent* operator &() { return &self; }
+	LDKMessageSendEvent* operator ->() { return &self; }
+	const LDKMessageSendEvent* operator &() const { return &self; }
+	const LDKMessageSendEvent* operator ->() const { return &self; }
+};
+class MessageSendEventsProvider {
 private:
-	LDKBlindedHopFeatures self;
+	LDKMessageSendEventsProvider 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; }
+	MessageSendEventsProvider(const MessageSendEventsProvider&) = delete;
+	MessageSendEventsProvider(MessageSendEventsProvider&& o) : self(o.self) { memset(&o, 0, sizeof(MessageSendEventsProvider)); }
+	MessageSendEventsProvider(LDKMessageSendEventsProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageSendEventsProvider)); }
+	operator LDKMessageSendEventsProvider() && { LDKMessageSendEventsProvider res = self; memset(&self, 0, sizeof(LDKMessageSendEventsProvider)); return res; }
+	~MessageSendEventsProvider() { MessageSendEventsProvider_free(self); }
+	MessageSendEventsProvider& operator=(MessageSendEventsProvider&& o) { MessageSendEventsProvider_free(self); self = o.self; memset(&o, 0, sizeof(MessageSendEventsProvider)); return *this; }
+	LDKMessageSendEventsProvider* operator &() { return &self; }
+	LDKMessageSendEventsProvider* operator ->() { return &self; }
+	const LDKMessageSendEventsProvider* operator &() const { return &self; }
+	const LDKMessageSendEventsProvider* operator ->() const { return &self; }
+	/**
+	 *  Gets the list of pending events which were generated by previous actions, clearing the list
+	 *  in the process.
+	 */
+	inline LDK::CVec_MessageSendEventZ get_and_clear_pending_msg_events();
 };
-class ChannelTypeFeatures {
+class OnionMessageProvider {
 private:
-	LDKChannelTypeFeatures self;
+	LDKOnionMessageProvider self;
 public:
-	ChannelTypeFeatures(const ChannelTypeFeatures&) = delete;
-	ChannelTypeFeatures(ChannelTypeFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelTypeFeatures)); }
-	ChannelTypeFeatures(LDKChannelTypeFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelTypeFeatures)); }
-	operator LDKChannelTypeFeatures() && { LDKChannelTypeFeatures res = self; memset(&self, 0, sizeof(LDKChannelTypeFeatures)); return res; }
-	~ChannelTypeFeatures() { ChannelTypeFeatures_free(self); }
-	ChannelTypeFeatures& operator=(ChannelTypeFeatures&& o) { ChannelTypeFeatures_free(self); self = o.self; memset(&o, 0, sizeof(ChannelTypeFeatures)); return *this; }
-	LDKChannelTypeFeatures* operator &() { return &self; }
-	LDKChannelTypeFeatures* operator ->() { return &self; }
-	const LDKChannelTypeFeatures* operator &() const { return &self; }
-	const LDKChannelTypeFeatures* operator ->() const { return &self; }
+	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 OnionMessageContents {
+class EventsProvider {
 private:
-	LDKOnionMessageContents self;
+	LDKEventsProvider 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; }
+	EventsProvider(const EventsProvider&) = delete;
+	EventsProvider(EventsProvider&& o) : self(o.self) { memset(&o, 0, sizeof(EventsProvider)); }
+	EventsProvider(LDKEventsProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEventsProvider)); }
+	operator LDKEventsProvider() && { LDKEventsProvider res = self; memset(&self, 0, sizeof(LDKEventsProvider)); return res; }
+	~EventsProvider() { EventsProvider_free(self); }
+	EventsProvider& operator=(EventsProvider&& o) { EventsProvider_free(self); self = o.self; memset(&o, 0, sizeof(EventsProvider)); return *this; }
+	LDKEventsProvider* operator &() { return &self; }
+	LDKEventsProvider* operator ->() { return &self; }
+	const LDKEventsProvider* operator &() const { return &self; }
+	const LDKEventsProvider* operator ->() const { return &self; }
+	/**
+	 *  Processes any events generated since the last call using the given event handler.
+	 * 
+	 *  See the trait-level documentation for requirements.
+	 */
+	inline void process_pending_events(struct LDKEventHandler handler);
 };
-class CustomOnionMessageContents {
+class EventHandler {
 private:
-	LDKCustomOnionMessageContents self;
+	LDKEventHandler 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; }
+	EventHandler(const EventHandler&) = delete;
+	EventHandler(EventHandler&& o) : self(o.self) { memset(&o, 0, sizeof(EventHandler)); }
+	EventHandler(LDKEventHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEventHandler)); }
+	operator LDKEventHandler() && { LDKEventHandler res = self; memset(&self, 0, sizeof(LDKEventHandler)); return res; }
+	~EventHandler() { EventHandler_free(self); }
+	EventHandler& operator=(EventHandler&& o) { EventHandler_free(self); self = o.self; memset(&o, 0, sizeof(EventHandler)); return *this; }
+	LDKEventHandler* operator &() { return &self; }
+	LDKEventHandler* operator ->() { return &self; }
+	const LDKEventHandler* operator &() const { return &self; }
+	const LDKEventHandler* operator ->() const { return &self; }
 	/**
-	 *  Returns the TLV type identifying the message contents. MUST be >= 64.
+	 *  Handles the given [`Event`].
+	 * 
+	 *  See [`EventsProvider`] for details that must be considered when implementing this method.
 	 */
-	inline uint64_t tlv_type();
+	inline void handle_event(struct LDKEvent event);
+};
+class Offer {
+private:
+	LDKOffer self;
+public:
+	Offer(const Offer&) = delete;
+	Offer(Offer&& o) : self(o.self) { memset(&o, 0, sizeof(Offer)); }
+	Offer(LDKOffer&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOffer)); }
+	operator LDKOffer() && { LDKOffer res = self; memset(&self, 0, sizeof(LDKOffer)); return res; }
+	~Offer() { Offer_free(self); }
+	Offer& operator=(Offer&& o) { Offer_free(self); self = o.self; memset(&o, 0, sizeof(Offer)); return *this; }
+	LDKOffer* operator &() { return &self; }
+	LDKOffer* operator ->() { return &self; }
+	const LDKOffer* operator &() const { return &self; }
+	const LDKOffer* operator ->() const { return &self; }
+};
+class Amount {
+private:
+	LDKAmount self;
+public:
+	Amount(const Amount&) = delete;
+	Amount(Amount&& o) : self(o.self) { memset(&o, 0, sizeof(Amount)); }
+	Amount(LDKAmount&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAmount)); }
+	operator LDKAmount() && { LDKAmount res = self; memset(&self, 0, sizeof(LDKAmount)); return res; }
+	~Amount() { Amount_free(self); }
+	Amount& operator=(Amount&& o) { Amount_free(self); self = o.self; memset(&o, 0, sizeof(Amount)); return *this; }
+	LDKAmount* operator &() { return &self; }
+	LDKAmount* operator ->() { return &self; }
+	const LDKAmount* operator &() const { return &self; }
+	const LDKAmount* operator ->() const { return &self; }
+};
+class Quantity {
+private:
+	LDKQuantity self;
+public:
+	Quantity(const Quantity&) = delete;
+	Quantity(Quantity&& o) : self(o.self) { memset(&o, 0, sizeof(Quantity)); }
+	Quantity(LDKQuantity&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKQuantity)); }
+	operator LDKQuantity() && { LDKQuantity res = self; memset(&self, 0, sizeof(LDKQuantity)); return res; }
+	~Quantity() { Quantity_free(self); }
+	Quantity& operator=(Quantity&& o) { Quantity_free(self); self = o.self; memset(&o, 0, sizeof(Quantity)); return *this; }
+	LDKQuantity* operator &() { return &self; }
+	LDKQuantity* operator ->() { return &self; }
+	const LDKQuantity* operator &() const { return &self; }
+	const LDKQuantity* operator ->() const { return &self; }
 };
 class NodeId {
 private:
@@ -2696,6 +2860,21 @@ public:
 	const LDKHostname* operator &() const { return &self; }
 	const LDKHostname* operator ->() const { return &self; }
 };
+class UntrustedString {
+private:
+	LDKUntrustedString self;
+public:
+	UntrustedString(const UntrustedString&) = delete;
+	UntrustedString(UntrustedString&& o) : self(o.self) { memset(&o, 0, sizeof(UntrustedString)); }
+	UntrustedString(LDKUntrustedString&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUntrustedString)); }
+	operator LDKUntrustedString() && { LDKUntrustedString res = self; memset(&self, 0, sizeof(LDKUntrustedString)); return res; }
+	~UntrustedString() { UntrustedString_free(self); }
+	UntrustedString& operator=(UntrustedString&& o) { UntrustedString_free(self); self = o.self; memset(&o, 0, sizeof(UntrustedString)); return *this; }
+	LDKUntrustedString* operator &() { return &self; }
+	LDKUntrustedString* operator ->() { return &self; }
+	const LDKUntrustedString* operator &() const { return &self; }
+	const LDKUntrustedString* operator ->() const { return &self; }
+};
 class PrintableString {
 private:
 	LDKPrintableString self;
@@ -3163,6 +3342,36 @@ public:
 	 */
 	inline LDK::CResult_COption_CustomOnionMessageContentsZDecodeErrorZ read_custom_message(uint64_t message_type, struct LDKu8slice buffer);
 };
+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 ParseError {
 private:
 	LDKParseError self;
@@ -3459,21 +3668,6 @@ public:
 	const LDKSignOrCreationError* operator &() const { return &self; }
 	const LDKSignOrCreationError* operator ->() const { return &self; }
 };
-class RapidGossipSync {
-private:
-	LDKRapidGossipSync self;
-public:
-	RapidGossipSync(const RapidGossipSync&) = delete;
-	RapidGossipSync(RapidGossipSync&& o) : self(o.self) { memset(&o, 0, sizeof(RapidGossipSync)); }
-	RapidGossipSync(LDKRapidGossipSync&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRapidGossipSync)); }
-	operator LDKRapidGossipSync() && { LDKRapidGossipSync res = self; memset(&self, 0, sizeof(LDKRapidGossipSync)); return res; }
-	~RapidGossipSync() { RapidGossipSync_free(self); }
-	RapidGossipSync& operator=(RapidGossipSync&& o) { RapidGossipSync_free(self); self = o.self; memset(&o, 0, sizeof(RapidGossipSync)); return *this; }
-	LDKRapidGossipSync* operator &() { return &self; }
-	LDKRapidGossipSync* operator ->() { return &self; }
-	const LDKRapidGossipSync* operator &() const { return &self; }
-	const LDKRapidGossipSync* operator ->() const { return &self; }
-};
 class Persister {
 private:
 	LDKPersister self;
@@ -4376,20 +4570,35 @@ public:
 	 */
 	inline LDK::InitFeatures provided_init_features(struct LDKPublicKey their_node_id);
 };
-class GraphSyncError {
+class UnsignedInvoiceRequest {
 private:
-	LDKGraphSyncError self;
+	LDKUnsignedInvoiceRequest self;
 public:
-	GraphSyncError(const GraphSyncError&) = delete;
-	GraphSyncError(GraphSyncError&& o) : self(o.self) { memset(&o, 0, sizeof(GraphSyncError)); }
-	GraphSyncError(LDKGraphSyncError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKGraphSyncError)); }
-	operator LDKGraphSyncError() && { LDKGraphSyncError res = self; memset(&self, 0, sizeof(LDKGraphSyncError)); return res; }
-	~GraphSyncError() { GraphSyncError_free(self); }
-	GraphSyncError& operator=(GraphSyncError&& o) { GraphSyncError_free(self); self = o.self; memset(&o, 0, sizeof(GraphSyncError)); return *this; }
-	LDKGraphSyncError* operator &() { return &self; }
-	LDKGraphSyncError* operator ->() { return &self; }
-	const LDKGraphSyncError* operator &() const { return &self; }
-	const LDKGraphSyncError* operator ->() const { return &self; }
+	UnsignedInvoiceRequest(const UnsignedInvoiceRequest&) = delete;
+	UnsignedInvoiceRequest(UnsignedInvoiceRequest&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedInvoiceRequest)); }
+	UnsignedInvoiceRequest(LDKUnsignedInvoiceRequest&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedInvoiceRequest)); }
+	operator LDKUnsignedInvoiceRequest() && { LDKUnsignedInvoiceRequest res = self; memset(&self, 0, sizeof(LDKUnsignedInvoiceRequest)); return res; }
+	~UnsignedInvoiceRequest() { UnsignedInvoiceRequest_free(self); }
+	UnsignedInvoiceRequest& operator=(UnsignedInvoiceRequest&& o) { UnsignedInvoiceRequest_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedInvoiceRequest)); return *this; }
+	LDKUnsignedInvoiceRequest* operator &() { return &self; }
+	LDKUnsignedInvoiceRequest* operator ->() { return &self; }
+	const LDKUnsignedInvoiceRequest* operator &() const { return &self; }
+	const LDKUnsignedInvoiceRequest* operator ->() const { return &self; }
+};
+class InvoiceRequest {
+private:
+	LDKInvoiceRequest self;
+public:
+	InvoiceRequest(const InvoiceRequest&) = delete;
+	InvoiceRequest(InvoiceRequest&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceRequest)); }
+	InvoiceRequest(LDKInvoiceRequest&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceRequest)); }
+	operator LDKInvoiceRequest() && { LDKInvoiceRequest res = self; memset(&self, 0, sizeof(LDKInvoiceRequest)); return res; }
+	~InvoiceRequest() { InvoiceRequest_free(self); }
+	InvoiceRequest& operator=(InvoiceRequest&& o) { InvoiceRequest_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceRequest)); return *this; }
+	LDKInvoiceRequest* operator &() { return &self; }
+	LDKInvoiceRequest* operator ->() { return &self; }
+	const LDKInvoiceRequest* operator &() const { return &self; }
+	const LDKInvoiceRequest* operator ->() const { return &self; }
 };
 class Level {
 private:
@@ -4473,6 +4682,21 @@ public:
 	const LDKFuture* operator &() const { return &self; }
 	const LDKFuture* operator ->() const { return &self; }
 };
+class Sleeper {
+private:
+	LDKSleeper self;
+public:
+	Sleeper(const Sleeper&) = delete;
+	Sleeper(Sleeper&& o) : self(o.self) { memset(&o, 0, sizeof(Sleeper)); }
+	Sleeper(LDKSleeper&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSleeper)); }
+	operator LDKSleeper() && { LDKSleeper res = self; memset(&self, 0, sizeof(LDKSleeper)); return res; }
+	~Sleeper() { Sleeper_free(self); }
+	Sleeper& operator=(Sleeper&& o) { Sleeper_free(self); self = o.self; memset(&o, 0, sizeof(Sleeper)); return *this; }
+	LDKSleeper* operator &() { return &self; }
+	LDKSleeper* operator ->() { return &self; }
+	const LDKSleeper* operator &() const { return &self; }
+	const LDKSleeper* operator ->() const { return &self; }
+};
 class MonitorUpdateId {
 private:
 	LDKMonitorUpdateId self;
@@ -4589,6 +4813,36 @@ public:
 	const LDKChainMonitor* operator &() const { return &self; }
 	const LDKChainMonitor* operator ->() const { return &self; }
 };
+class GraphSyncError {
+private:
+	LDKGraphSyncError self;
+public:
+	GraphSyncError(const GraphSyncError&) = delete;
+	GraphSyncError(GraphSyncError&& o) : self(o.self) { memset(&o, 0, sizeof(GraphSyncError)); }
+	GraphSyncError(LDKGraphSyncError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKGraphSyncError)); }
+	operator LDKGraphSyncError() && { LDKGraphSyncError res = self; memset(&self, 0, sizeof(LDKGraphSyncError)); return res; }
+	~GraphSyncError() { GraphSyncError_free(self); }
+	GraphSyncError& operator=(GraphSyncError&& o) { GraphSyncError_free(self); self = o.self; memset(&o, 0, sizeof(GraphSyncError)); return *this; }
+	LDKGraphSyncError* operator &() { return &self; }
+	LDKGraphSyncError* operator ->() { return &self; }
+	const LDKGraphSyncError* operator &() const { return &self; }
+	const LDKGraphSyncError* operator ->() const { return &self; }
+};
+class RapidGossipSync {
+private:
+	LDKRapidGossipSync self;
+public:
+	RapidGossipSync(const RapidGossipSync&) = delete;
+	RapidGossipSync(RapidGossipSync&& o) : self(o.self) { memset(&o, 0, sizeof(RapidGossipSync)); }
+	RapidGossipSync(LDKRapidGossipSync&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRapidGossipSync)); }
+	operator LDKRapidGossipSync() && { LDKRapidGossipSync res = self; memset(&self, 0, sizeof(LDKRapidGossipSync)); return res; }
+	~RapidGossipSync() { RapidGossipSync_free(self); }
+	RapidGossipSync& operator=(RapidGossipSync&& o) { RapidGossipSync_free(self); self = o.self; memset(&o, 0, sizeof(RapidGossipSync)); return *this; }
+	LDKRapidGossipSync* operator &() { return &self; }
+	LDKRapidGossipSync* operator ->() { return &self; }
+	const LDKRapidGossipSync* operator &() const { return &self; }
+	const LDKRapidGossipSync* operator ->() const { return &self; }
+};
 class CResult_LockedChannelMonitorNoneZ {
 private:
 	LDKCResult_LockedChannelMonitorNoneZ self;
@@ -4604,6 +4858,21 @@ public:
 	const LDKCResult_LockedChannelMonitorNoneZ* operator &() const { return &self; }
 	const LDKCResult_LockedChannelMonitorNoneZ* operator ->() const { return &self; }
 };
+class CVec_C2Tuple_BlindedPayInfoBlindedPathZZ {
+private:
+	LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ self;
+public:
+	CVec_C2Tuple_BlindedPayInfoBlindedPathZZ(const CVec_C2Tuple_BlindedPayInfoBlindedPathZZ&) = delete;
+	CVec_C2Tuple_BlindedPayInfoBlindedPathZZ(CVec_C2Tuple_BlindedPayInfoBlindedPathZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_BlindedPayInfoBlindedPathZZ)); }
+	CVec_C2Tuple_BlindedPayInfoBlindedPathZZ(LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ)); }
+	operator LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ() && { LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ)); return res; }
+	~CVec_C2Tuple_BlindedPayInfoBlindedPathZZ() { CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_free(self); }
+	CVec_C2Tuple_BlindedPayInfoBlindedPathZZ& operator=(CVec_C2Tuple_BlindedPayInfoBlindedPathZZ&& o) { CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_BlindedPayInfoBlindedPathZZ)); return *this; }
+	LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ* operator &() { return &self; }
+	LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ* operator ->() { return &self; }
+	const LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ* operator &() const { return &self; }
+	const LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ* operator ->() const { return &self; }
+};
 class CResult_PhantomRouteHintsDecodeErrorZ {
 private:
 	LDKCResult_PhantomRouteHintsDecodeErrorZ self;
@@ -4964,6 +5233,21 @@ public:
 	const LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator ->() const { return &self; }
 };
+class COption_DurationZ {
+private:
+	LDKCOption_DurationZ self;
+public:
+	COption_DurationZ(const COption_DurationZ&) = delete;
+	COption_DurationZ(COption_DurationZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_DurationZ)); }
+	COption_DurationZ(LDKCOption_DurationZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_DurationZ)); }
+	operator LDKCOption_DurationZ() && { LDKCOption_DurationZ res = self; memset(&self, 0, sizeof(LDKCOption_DurationZ)); return res; }
+	~COption_DurationZ() { COption_DurationZ_free(self); }
+	COption_DurationZ& operator=(COption_DurationZ&& o) { COption_DurationZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_DurationZ)); return *this; }
+	LDKCOption_DurationZ* operator &() { return &self; }
+	LDKCOption_DurationZ* operator ->() { return &self; }
+	const LDKCOption_DurationZ* operator &() const { return &self; }
+	const LDKCOption_DurationZ* operator ->() const { return &self; }
+};
 class CResult_ErrorMessageDecodeErrorZ {
 private:
 	LDKCResult_ErrorMessageDecodeErrorZ self;
@@ -5444,6 +5728,21 @@ public:
 	const LDKCVec_RouteHintHopZ* operator &() const { return &self; }
 	const LDKCVec_RouteHintHopZ* operator ->() const { return &self; }
 };
+class CResult_UntrustedStringDecodeErrorZ {
+private:
+	LDKCResult_UntrustedStringDecodeErrorZ self;
+public:
+	CResult_UntrustedStringDecodeErrorZ(const CResult_UntrustedStringDecodeErrorZ&) = delete;
+	CResult_UntrustedStringDecodeErrorZ(CResult_UntrustedStringDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UntrustedStringDecodeErrorZ)); }
+	CResult_UntrustedStringDecodeErrorZ(LDKCResult_UntrustedStringDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UntrustedStringDecodeErrorZ)); }
+	operator LDKCResult_UntrustedStringDecodeErrorZ() && { LDKCResult_UntrustedStringDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UntrustedStringDecodeErrorZ)); return res; }
+	~CResult_UntrustedStringDecodeErrorZ() { CResult_UntrustedStringDecodeErrorZ_free(self); }
+	CResult_UntrustedStringDecodeErrorZ& operator=(CResult_UntrustedStringDecodeErrorZ&& o) { CResult_UntrustedStringDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UntrustedStringDecodeErrorZ)); return *this; }
+	LDKCResult_UntrustedStringDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_UntrustedStringDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_UntrustedStringDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_UntrustedStringDecodeErrorZ* operator ->() const { return &self; }
+};
 class CResult_PaymentParametersDecodeErrorZ {
 private:
 	LDKCResult_PaymentParametersDecodeErrorZ self;
@@ -5744,6 +6043,21 @@ public:
 	const LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator ->() const { return &self; }
 };
+class CVec_BlindedPathZ {
+private:
+	LDKCVec_BlindedPathZ self;
+public:
+	CVec_BlindedPathZ(const CVec_BlindedPathZ&) = delete;
+	CVec_BlindedPathZ(CVec_BlindedPathZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_BlindedPathZ)); }
+	CVec_BlindedPathZ(LDKCVec_BlindedPathZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_BlindedPathZ)); }
+	operator LDKCVec_BlindedPathZ() && { LDKCVec_BlindedPathZ res = self; memset(&self, 0, sizeof(LDKCVec_BlindedPathZ)); return res; }
+	~CVec_BlindedPathZ() { CVec_BlindedPathZ_free(self); }
+	CVec_BlindedPathZ& operator=(CVec_BlindedPathZ&& o) { CVec_BlindedPathZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_BlindedPathZ)); return *this; }
+	LDKCVec_BlindedPathZ* operator &() { return &self; }
+	LDKCVec_BlindedPathZ* operator ->() { return &self; }
+	const LDKCVec_BlindedPathZ* operator &() const { return &self; }
+	const LDKCVec_BlindedPathZ* operator ->() const { return &self; }
+};
 class CResult_NoneLightningErrorZ {
 private:
 	LDKCResult_NoneLightningErrorZ self;
@@ -5774,21 +6088,6 @@ public:
 	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;
@@ -5834,20 +6133,35 @@ public:
 	const LDKCOption_CVec_NetAddressZZ* operator &() const { return &self; }
 	const LDKCOption_CVec_NetAddressZZ* operator ->() const { return &self; }
 };
-class CResult_NonePeerHandleErrorZ {
+class CResult_PaymentFailureReasonDecodeErrorZ {
 private:
-	LDKCResult_NonePeerHandleErrorZ self;
+	LDKCResult_PaymentFailureReasonDecodeErrorZ self;
+public:
+	CResult_PaymentFailureReasonDecodeErrorZ(const CResult_PaymentFailureReasonDecodeErrorZ&) = delete;
+	CResult_PaymentFailureReasonDecodeErrorZ(CResult_PaymentFailureReasonDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentFailureReasonDecodeErrorZ)); }
+	CResult_PaymentFailureReasonDecodeErrorZ(LDKCResult_PaymentFailureReasonDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentFailureReasonDecodeErrorZ)); }
+	operator LDKCResult_PaymentFailureReasonDecodeErrorZ() && { LDKCResult_PaymentFailureReasonDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentFailureReasonDecodeErrorZ)); return res; }
+	~CResult_PaymentFailureReasonDecodeErrorZ() { CResult_PaymentFailureReasonDecodeErrorZ_free(self); }
+	CResult_PaymentFailureReasonDecodeErrorZ& operator=(CResult_PaymentFailureReasonDecodeErrorZ&& o) { CResult_PaymentFailureReasonDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentFailureReasonDecodeErrorZ)); return *this; }
+	LDKCResult_PaymentFailureReasonDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_PaymentFailureReasonDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_PaymentFailureReasonDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_PaymentFailureReasonDecodeErrorZ* operator ->() const { return &self; }
+};
+class C2Tuple_PublicKeyCOption_NetAddressZZ {
+private:
+	LDKC2Tuple_PublicKeyCOption_NetAddressZZ 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; }
+	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__u832APIErrorZ {
 private:
@@ -5909,6 +6223,21 @@ public:
 	const LDKCResult_RoutingFeesDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_RoutingFeesDecodeErrorZ* 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_PayeePubKeyErrorZ {
 private:
 	LDKCResult_PayeePubKeyErrorZ self;
@@ -6164,6 +6493,21 @@ public:
 	const LDKCVec_C2Tuple_u32ScriptZZ* operator &() const { return &self; }
 	const LDKCVec_C2Tuple_u32ScriptZZ* operator ->() const { return &self; }
 };
+class CVec_BlindedHopZ {
+private:
+	LDKCVec_BlindedHopZ self;
+public:
+	CVec_BlindedHopZ(const CVec_BlindedHopZ&) = delete;
+	CVec_BlindedHopZ(CVec_BlindedHopZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_BlindedHopZ)); }
+	CVec_BlindedHopZ(LDKCVec_BlindedHopZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_BlindedHopZ)); }
+	operator LDKCVec_BlindedHopZ() && { LDKCVec_BlindedHopZ res = self; memset(&self, 0, sizeof(LDKCVec_BlindedHopZ)); return res; }
+	~CVec_BlindedHopZ() { CVec_BlindedHopZ_free(self); }
+	CVec_BlindedHopZ& operator=(CVec_BlindedHopZ&& o) { CVec_BlindedHopZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_BlindedHopZ)); return *this; }
+	LDKCVec_BlindedHopZ* operator &() { return &self; }
+	LDKCVec_BlindedHopZ* operator ->() { return &self; }
+	const LDKCVec_BlindedHopZ* operator &() const { return &self; }
+	const LDKCVec_BlindedHopZ* operator ->() const { return &self; }
+};
 class CResult_COption_ClosureReasonZDecodeErrorZ {
 private:
 	LDKCResult_COption_ClosureReasonZDecodeErrorZ self;
@@ -6599,6 +6943,21 @@ public:
 	const LDKCResult_InvoiceFeaturesDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_InvoiceFeaturesDecodeErrorZ* operator ->() const { return &self; }
 };
+class C2Tuple_BlindedPayInfoBlindedPathZ {
+private:
+	LDKC2Tuple_BlindedPayInfoBlindedPathZ self;
+public:
+	C2Tuple_BlindedPayInfoBlindedPathZ(const C2Tuple_BlindedPayInfoBlindedPathZ&) = delete;
+	C2Tuple_BlindedPayInfoBlindedPathZ(C2Tuple_BlindedPayInfoBlindedPathZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_BlindedPayInfoBlindedPathZ)); }
+	C2Tuple_BlindedPayInfoBlindedPathZ(LDKC2Tuple_BlindedPayInfoBlindedPathZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_BlindedPayInfoBlindedPathZ)); }
+	operator LDKC2Tuple_BlindedPayInfoBlindedPathZ() && { LDKC2Tuple_BlindedPayInfoBlindedPathZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_BlindedPayInfoBlindedPathZ)); return res; }
+	~C2Tuple_BlindedPayInfoBlindedPathZ() { C2Tuple_BlindedPayInfoBlindedPathZ_free(self); }
+	C2Tuple_BlindedPayInfoBlindedPathZ& operator=(C2Tuple_BlindedPayInfoBlindedPathZ&& o) { C2Tuple_BlindedPayInfoBlindedPathZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_BlindedPayInfoBlindedPathZ)); return *this; }
+	LDKC2Tuple_BlindedPayInfoBlindedPathZ* operator &() { return &self; }
+	LDKC2Tuple_BlindedPayInfoBlindedPathZ* operator ->() { return &self; }
+	const LDKC2Tuple_BlindedPayInfoBlindedPathZ* operator &() const { return &self; }
+	const LDKC2Tuple_BlindedPayInfoBlindedPathZ* operator ->() const { return &self; }
+};
 class CResult_ChannelMonitorUpdateDecodeErrorZ {
 private:
 	LDKCResult_ChannelMonitorUpdateDecodeErrorZ self;
@@ -6629,21 +6988,6 @@ public:
 	const LDKCResult_ReplyChannelRangeDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_ReplyChannelRangeDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_InvoiceSignOrCreationErrorZ {
-private:
-	LDKCResult_InvoiceSignOrCreationErrorZ self;
-public:
-	CResult_InvoiceSignOrCreationErrorZ(const CResult_InvoiceSignOrCreationErrorZ&) = delete;
-	CResult_InvoiceSignOrCreationErrorZ(CResult_InvoiceSignOrCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceSignOrCreationErrorZ)); }
-	CResult_InvoiceSignOrCreationErrorZ(LDKCResult_InvoiceSignOrCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceSignOrCreationErrorZ)); }
-	operator LDKCResult_InvoiceSignOrCreationErrorZ() && { LDKCResult_InvoiceSignOrCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceSignOrCreationErrorZ)); return res; }
-	~CResult_InvoiceSignOrCreationErrorZ() { CResult_InvoiceSignOrCreationErrorZ_free(self); }
-	CResult_InvoiceSignOrCreationErrorZ& operator=(CResult_InvoiceSignOrCreationErrorZ&& o) { CResult_InvoiceSignOrCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceSignOrCreationErrorZ)); return *this; }
-	LDKCResult_InvoiceSignOrCreationErrorZ* operator &() { return &self; }
-	LDKCResult_InvoiceSignOrCreationErrorZ* operator ->() { return &self; }
-	const LDKCResult_InvoiceSignOrCreationErrorZ* operator &() const { return &self; }
-	const LDKCResult_InvoiceSignOrCreationErrorZ* operator ->() const { return &self; }
-};
 class CResult_TrustedClosingTransactionNoneZ {
 private:
 	LDKCResult_TrustedClosingTransactionNoneZ self;
@@ -6734,6 +7078,21 @@ public:
 	const LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator ->() const { return &self; }
 };
+class CResult_InvoiceSignOrCreationErrorZ {
+private:
+	LDKCResult_InvoiceSignOrCreationErrorZ self;
+public:
+	CResult_InvoiceSignOrCreationErrorZ(const CResult_InvoiceSignOrCreationErrorZ&) = delete;
+	CResult_InvoiceSignOrCreationErrorZ(CResult_InvoiceSignOrCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceSignOrCreationErrorZ)); }
+	CResult_InvoiceSignOrCreationErrorZ(LDKCResult_InvoiceSignOrCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceSignOrCreationErrorZ)); }
+	operator LDKCResult_InvoiceSignOrCreationErrorZ() && { LDKCResult_InvoiceSignOrCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceSignOrCreationErrorZ)); return res; }
+	~CResult_InvoiceSignOrCreationErrorZ() { CResult_InvoiceSignOrCreationErrorZ_free(self); }
+	CResult_InvoiceSignOrCreationErrorZ& operator=(CResult_InvoiceSignOrCreationErrorZ&& o) { CResult_InvoiceSignOrCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceSignOrCreationErrorZ)); return *this; }
+	LDKCResult_InvoiceSignOrCreationErrorZ* operator &() { return &self; }
+	LDKCResult_InvoiceSignOrCreationErrorZ* operator ->() { return &self; }
+	const LDKCResult_InvoiceSignOrCreationErrorZ* operator &() const { return &self; }
+	const LDKCResult_InvoiceSignOrCreationErrorZ* operator ->() const { return &self; }
+};
 class CResult_InitFeaturesDecodeErrorZ {
 private:
 	LDKCResult_InitFeaturesDecodeErrorZ self;
@@ -6884,21 +7243,6 @@ public:
 	const LDKCResult_ProbabilisticScorerDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_ProbabilisticScorerDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_TxCreationKeysDecodeErrorZ {
-private:
-	LDKCResult_TxCreationKeysDecodeErrorZ self;
-public:
-	CResult_TxCreationKeysDecodeErrorZ(const CResult_TxCreationKeysDecodeErrorZ&) = delete;
-	CResult_TxCreationKeysDecodeErrorZ(CResult_TxCreationKeysDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxCreationKeysDecodeErrorZ)); }
-	CResult_TxCreationKeysDecodeErrorZ(LDKCResult_TxCreationKeysDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxCreationKeysDecodeErrorZ)); }
-	operator LDKCResult_TxCreationKeysDecodeErrorZ() && { LDKCResult_TxCreationKeysDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxCreationKeysDecodeErrorZ)); return res; }
-	~CResult_TxCreationKeysDecodeErrorZ() { CResult_TxCreationKeysDecodeErrorZ_free(self); }
-	CResult_TxCreationKeysDecodeErrorZ& operator=(CResult_TxCreationKeysDecodeErrorZ&& o) { CResult_TxCreationKeysDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxCreationKeysDecodeErrorZ)); return *this; }
-	LDKCResult_TxCreationKeysDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_TxCreationKeysDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_TxCreationKeysDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_TxCreationKeysDecodeErrorZ* operator ->() const { return &self; }
-};
 class C2Tuple_usizeTransactionZ {
 private:
 	LDKC2Tuple_usizeTransactionZ self;
@@ -6914,6 +7258,21 @@ public:
 	const LDKC2Tuple_usizeTransactionZ* operator &() const { return &self; }
 	const LDKC2Tuple_usizeTransactionZ* operator ->() const { return &self; }
 };
+class CResult_TxCreationKeysDecodeErrorZ {
+private:
+	LDKCResult_TxCreationKeysDecodeErrorZ self;
+public:
+	CResult_TxCreationKeysDecodeErrorZ(const CResult_TxCreationKeysDecodeErrorZ&) = delete;
+	CResult_TxCreationKeysDecodeErrorZ(CResult_TxCreationKeysDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxCreationKeysDecodeErrorZ)); }
+	CResult_TxCreationKeysDecodeErrorZ(LDKCResult_TxCreationKeysDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxCreationKeysDecodeErrorZ)); }
+	operator LDKCResult_TxCreationKeysDecodeErrorZ() && { LDKCResult_TxCreationKeysDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxCreationKeysDecodeErrorZ)); return res; }
+	~CResult_TxCreationKeysDecodeErrorZ() { CResult_TxCreationKeysDecodeErrorZ_free(self); }
+	CResult_TxCreationKeysDecodeErrorZ& operator=(CResult_TxCreationKeysDecodeErrorZ&& o) { CResult_TxCreationKeysDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxCreationKeysDecodeErrorZ)); return *this; }
+	LDKCResult_TxCreationKeysDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_TxCreationKeysDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_TxCreationKeysDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_TxCreationKeysDecodeErrorZ* operator ->() const { return &self; }
+};
 class CResult_NodeAnnouncementDecodeErrorZ {
 private:
 	LDKCResult_NodeAnnouncementDecodeErrorZ self;
@@ -6929,6 +7288,21 @@ public:
 	const LDKCResult_NodeAnnouncementDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_NodeAnnouncementDecodeErrorZ* 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 CResult_BlindedPathDecodeErrorZ {
 private:
 	LDKCResult_BlindedPathDecodeErrorZ self;
@@ -6944,20 +7318,20 @@ public:
 	const LDKCResult_BlindedPathDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_BlindedPathDecodeErrorZ* operator ->() const { return &self; }
 };
-class CVec_ChannelMonitorZ {
+class CVec_FutureZ {
 private:
-	LDKCVec_ChannelMonitorZ self;
+	LDKCVec_FutureZ 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; }
+	CVec_FutureZ(const CVec_FutureZ&) = delete;
+	CVec_FutureZ(CVec_FutureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_FutureZ)); }
+	CVec_FutureZ(LDKCVec_FutureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_FutureZ)); }
+	operator LDKCVec_FutureZ() && { LDKCVec_FutureZ res = self; memset(&self, 0, sizeof(LDKCVec_FutureZ)); return res; }
+	~CVec_FutureZ() { CVec_FutureZ_free(self); }
+	CVec_FutureZ& operator=(CVec_FutureZ&& o) { CVec_FutureZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_FutureZ)); return *this; }
+	LDKCVec_FutureZ* operator &() { return &self; }
+	LDKCVec_FutureZ* operator ->() { return &self; }
+	const LDKCVec_FutureZ* operator &() const { return &self; }
+	const LDKCVec_FutureZ* operator ->() const { return &self; }
 };
 class CResult_RouteHopDecodeErrorZ {
 private:
@@ -7049,6 +7423,21 @@ public:
 	const LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* operator &() const { return &self; }
 	const LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* operator ->() const { return &self; }
 };
+class CVec_PathZ {
+private:
+	LDKCVec_PathZ self;
+public:
+	CVec_PathZ(const CVec_PathZ&) = delete;
+	CVec_PathZ(CVec_PathZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PathZ)); }
+	CVec_PathZ(LDKCVec_PathZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PathZ)); }
+	operator LDKCVec_PathZ() && { LDKCVec_PathZ res = self; memset(&self, 0, sizeof(LDKCVec_PathZ)); return res; }
+	~CVec_PathZ() { CVec_PathZ_free(self); }
+	CVec_PathZ& operator=(CVec_PathZ&& o) { CVec_PathZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PathZ)); return *this; }
+	LDKCVec_PathZ* operator &() { return &self; }
+	LDKCVec_PathZ* operator ->() { return &self; }
+	const LDKCVec_PathZ* operator &() const { return &self; }
+	const LDKCVec_PathZ* operator ->() const { return &self; }
+};
 class CResult_NetworkGraphDecodeErrorZ {
 private:
 	LDKCResult_NetworkGraphDecodeErrorZ self;
@@ -7094,20 +7483,20 @@ public:
 	const LDKCVec_NodeIdZ* operator &() const { return &self; }
 	const LDKCVec_NodeIdZ* operator ->() const { return &self; }
 };
-class CResult_RouteLightningErrorZ {
+class CVec_u8Z {
 private:
-	LDKCResult_RouteLightningErrorZ self;
+	LDKCVec_u8Z self;
 public:
-	CResult_RouteLightningErrorZ(const CResult_RouteLightningErrorZ&) = delete;
-	CResult_RouteLightningErrorZ(CResult_RouteLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteLightningErrorZ)); }
-	CResult_RouteLightningErrorZ(LDKCResult_RouteLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteLightningErrorZ)); }
-	operator LDKCResult_RouteLightningErrorZ() && { LDKCResult_RouteLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteLightningErrorZ)); return res; }
-	~CResult_RouteLightningErrorZ() { CResult_RouteLightningErrorZ_free(self); }
-	CResult_RouteLightningErrorZ& operator=(CResult_RouteLightningErrorZ&& o) { CResult_RouteLightningErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteLightningErrorZ)); return *this; }
-	LDKCResult_RouteLightningErrorZ* operator &() { return &self; }
-	LDKCResult_RouteLightningErrorZ* operator ->() { return &self; }
-	const LDKCResult_RouteLightningErrorZ* operator &() const { return &self; }
-	const LDKCResult_RouteLightningErrorZ* operator ->() const { return &self; }
+	CVec_u8Z(const CVec_u8Z&) = delete;
+	CVec_u8Z(CVec_u8Z&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_u8Z)); }
+	CVec_u8Z(LDKCVec_u8Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_u8Z)); }
+	operator LDKCVec_u8Z() && { LDKCVec_u8Z res = self; memset(&self, 0, sizeof(LDKCVec_u8Z)); return res; }
+	~CVec_u8Z() { CVec_u8Z_free(self); }
+	CVec_u8Z& operator=(CVec_u8Z&& o) { CVec_u8Z_free(self); self = o.self; memset(&o, 0, sizeof(CVec_u8Z)); return *this; }
+	LDKCVec_u8Z* operator &() { return &self; }
+	LDKCVec_u8Z* operator ->() { return &self; }
+	const LDKCVec_u8Z* operator &() const { return &self; }
+	const LDKCVec_u8Z* operator ->() const { return &self; }
 };
 class CResult_ChannelPublicKeysDecodeErrorZ {
 private:
@@ -7124,20 +7513,20 @@ public:
 	const LDKCResult_ChannelPublicKeysDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_ChannelPublicKeysDecodeErrorZ* operator ->() const { return &self; }
 };
-class CVec_u8Z {
+class CResult_RouteLightningErrorZ {
 private:
-	LDKCVec_u8Z self;
+	LDKCResult_RouteLightningErrorZ self;
 public:
-	CVec_u8Z(const CVec_u8Z&) = delete;
-	CVec_u8Z(CVec_u8Z&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_u8Z)); }
-	CVec_u8Z(LDKCVec_u8Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_u8Z)); }
-	operator LDKCVec_u8Z() && { LDKCVec_u8Z res = self; memset(&self, 0, sizeof(LDKCVec_u8Z)); return res; }
-	~CVec_u8Z() { CVec_u8Z_free(self); }
-	CVec_u8Z& operator=(CVec_u8Z&& o) { CVec_u8Z_free(self); self = o.self; memset(&o, 0, sizeof(CVec_u8Z)); return *this; }
-	LDKCVec_u8Z* operator &() { return &self; }
-	LDKCVec_u8Z* operator ->() { return &self; }
-	const LDKCVec_u8Z* operator &() const { return &self; }
-	const LDKCVec_u8Z* operator ->() const { return &self; }
+	CResult_RouteLightningErrorZ(const CResult_RouteLightningErrorZ&) = delete;
+	CResult_RouteLightningErrorZ(CResult_RouteLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteLightningErrorZ)); }
+	CResult_RouteLightningErrorZ(LDKCResult_RouteLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteLightningErrorZ)); }
+	operator LDKCResult_RouteLightningErrorZ() && { LDKCResult_RouteLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteLightningErrorZ)); return res; }
+	~CResult_RouteLightningErrorZ() { CResult_RouteLightningErrorZ_free(self); }
+	CResult_RouteLightningErrorZ& operator=(CResult_RouteLightningErrorZ&& o) { CResult_RouteLightningErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteLightningErrorZ)); return *this; }
+	LDKCResult_RouteLightningErrorZ* operator &() { return &self; }
+	LDKCResult_RouteLightningErrorZ* operator ->() { return &self; }
+	const LDKCResult_RouteLightningErrorZ* operator &() const { return &self; }
+	const LDKCResult_RouteLightningErrorZ* operator ->() const { return &self; }
 };
 class CResult_NonePaymentSendFailureZ {
 private:
@@ -7379,6 +7768,21 @@ public:
 	const LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* operator ->() const { return &self; }
 };
+class CResult_BlindedPayInfoDecodeErrorZ {
+private:
+	LDKCResult_BlindedPayInfoDecodeErrorZ self;
+public:
+	CResult_BlindedPayInfoDecodeErrorZ(const CResult_BlindedPayInfoDecodeErrorZ&) = delete;
+	CResult_BlindedPayInfoDecodeErrorZ(CResult_BlindedPayInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedPayInfoDecodeErrorZ)); }
+	CResult_BlindedPayInfoDecodeErrorZ(LDKCResult_BlindedPayInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedPayInfoDecodeErrorZ)); }
+	operator LDKCResult_BlindedPayInfoDecodeErrorZ() && { LDKCResult_BlindedPayInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedPayInfoDecodeErrorZ)); return res; }
+	~CResult_BlindedPayInfoDecodeErrorZ() { CResult_BlindedPayInfoDecodeErrorZ_free(self); }
+	CResult_BlindedPayInfoDecodeErrorZ& operator=(CResult_BlindedPayInfoDecodeErrorZ&& o) { CResult_BlindedPayInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedPayInfoDecodeErrorZ)); return *this; }
+	LDKCResult_BlindedPayInfoDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_BlindedPayInfoDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_BlindedPayInfoDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_BlindedPayInfoDecodeErrorZ* operator ->() const { return &self; }
+};
 class CResult_SharedSecretNoneZ {
 private:
 	LDKCResult_SharedSecretNoneZ self;
@@ -7574,6 +7978,21 @@ public:
 	const LDKCVec_RouteHintZ* operator &() const { return &self; }
 	const LDKCVec_RouteHintZ* operator ->() const { return &self; }
 };
+class COption_PaymentFailureReasonZ {
+private:
+	LDKCOption_PaymentFailureReasonZ self;
+public:
+	COption_PaymentFailureReasonZ(const COption_PaymentFailureReasonZ&) = delete;
+	COption_PaymentFailureReasonZ(COption_PaymentFailureReasonZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_PaymentFailureReasonZ)); }
+	COption_PaymentFailureReasonZ(LDKCOption_PaymentFailureReasonZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_PaymentFailureReasonZ)); }
+	operator LDKCOption_PaymentFailureReasonZ() && { LDKCOption_PaymentFailureReasonZ res = self; memset(&self, 0, sizeof(LDKCOption_PaymentFailureReasonZ)); return res; }
+	~COption_PaymentFailureReasonZ() { COption_PaymentFailureReasonZ_free(self); }
+	COption_PaymentFailureReasonZ& operator=(COption_PaymentFailureReasonZ&& o) { COption_PaymentFailureReasonZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_PaymentFailureReasonZ)); return *this; }
+	LDKCOption_PaymentFailureReasonZ* operator &() { return &self; }
+	LDKCOption_PaymentFailureReasonZ* operator ->() { return &self; }
+	const LDKCOption_PaymentFailureReasonZ* operator &() const { return &self; }
+	const LDKCOption_PaymentFailureReasonZ* operator ->() const { return &self; }
+};
 class COption_u16Z {
 private:
 	LDKCOption_u16Z self;
@@ -7589,20 +8008,35 @@ public:
 	const LDKCOption_u16Z* operator &() const { return &self; }
 	const LDKCOption_u16Z* operator ->() const { return &self; }
 };
-class CVec_CVec_RouteHopZZ {
+class CVec_ChainHashZ {
+private:
+	LDKCVec_ChainHashZ self;
+public:
+	CVec_ChainHashZ(const CVec_ChainHashZ&) = delete;
+	CVec_ChainHashZ(CVec_ChainHashZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ChainHashZ)); }
+	CVec_ChainHashZ(LDKCVec_ChainHashZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ChainHashZ)); }
+	operator LDKCVec_ChainHashZ() && { LDKCVec_ChainHashZ res = self; memset(&self, 0, sizeof(LDKCVec_ChainHashZ)); return res; }
+	~CVec_ChainHashZ() { CVec_ChainHashZ_free(self); }
+	CVec_ChainHashZ& operator=(CVec_ChainHashZ&& o) { CVec_ChainHashZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ChainHashZ)); return *this; }
+	LDKCVec_ChainHashZ* operator &() { return &self; }
+	LDKCVec_ChainHashZ* operator ->() { return &self; }
+	const LDKCVec_ChainHashZ* operator &() const { return &self; }
+	const LDKCVec_ChainHashZ* operator ->() const { return &self; }
+};
+class CResult_BlindedTailDecodeErrorZ {
 private:
-	LDKCVec_CVec_RouteHopZZ self;
+	LDKCResult_BlindedTailDecodeErrorZ 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; }
+	CResult_BlindedTailDecodeErrorZ(const CResult_BlindedTailDecodeErrorZ&) = delete;
+	CResult_BlindedTailDecodeErrorZ(CResult_BlindedTailDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedTailDecodeErrorZ)); }
+	CResult_BlindedTailDecodeErrorZ(LDKCResult_BlindedTailDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedTailDecodeErrorZ)); }
+	operator LDKCResult_BlindedTailDecodeErrorZ() && { LDKCResult_BlindedTailDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedTailDecodeErrorZ)); return res; }
+	~CResult_BlindedTailDecodeErrorZ() { CResult_BlindedTailDecodeErrorZ_free(self); }
+	CResult_BlindedTailDecodeErrorZ& operator=(CResult_BlindedTailDecodeErrorZ&& o) { CResult_BlindedTailDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedTailDecodeErrorZ)); return *this; }
+	LDKCResult_BlindedTailDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_BlindedTailDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_BlindedTailDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_BlindedTailDecodeErrorZ* operator ->() const { return &self; }
 };
 class CVec_C2Tuple_PublicKeyTypeZZ {
 private:
@@ -7724,21 +8158,6 @@ public:
 	const LDKCResult_ChannelDetailsDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_ChannelDetailsDecodeErrorZ* operator ->() const { return &self; }
 };
-class CVec_PublicKeyZ {
-private:
-	LDKCVec_PublicKeyZ self;
-public:
-	CVec_PublicKeyZ(const CVec_PublicKeyZ&) = delete;
-	CVec_PublicKeyZ(CVec_PublicKeyZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PublicKeyZ)); }
-	CVec_PublicKeyZ(LDKCVec_PublicKeyZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PublicKeyZ)); }
-	operator LDKCVec_PublicKeyZ() && { LDKCVec_PublicKeyZ res = self; memset(&self, 0, sizeof(LDKCVec_PublicKeyZ)); return res; }
-	~CVec_PublicKeyZ() { CVec_PublicKeyZ_free(self); }
-	CVec_PublicKeyZ& operator=(CVec_PublicKeyZ&& o) { CVec_PublicKeyZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PublicKeyZ)); return *this; }
-	LDKCVec_PublicKeyZ* operator &() { return &self; }
-	LDKCVec_PublicKeyZ* operator ->() { return &self; }
-	const LDKCVec_PublicKeyZ* operator &() const { return &self; }
-	const LDKCVec_PublicKeyZ* operator ->() const { return &self; }
-};
 class CVec_C2Tuple_usizeTransactionZZ {
 private:
 	LDKCVec_C2Tuple_usizeTransactionZZ self;
@@ -7754,6 +8173,21 @@ public:
 	const LDKCVec_C2Tuple_usizeTransactionZZ* operator &() const { return &self; }
 	const LDKCVec_C2Tuple_usizeTransactionZZ* operator ->() const { return &self; }
 };
+class CVec_PublicKeyZ {
+private:
+	LDKCVec_PublicKeyZ self;
+public:
+	CVec_PublicKeyZ(const CVec_PublicKeyZ&) = delete;
+	CVec_PublicKeyZ(CVec_PublicKeyZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PublicKeyZ)); }
+	CVec_PublicKeyZ(LDKCVec_PublicKeyZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PublicKeyZ)); }
+	operator LDKCVec_PublicKeyZ() && { LDKCVec_PublicKeyZ res = self; memset(&self, 0, sizeof(LDKCVec_PublicKeyZ)); return res; }
+	~CVec_PublicKeyZ() { CVec_PublicKeyZ_free(self); }
+	CVec_PublicKeyZ& operator=(CVec_PublicKeyZ&& o) { CVec_PublicKeyZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PublicKeyZ)); return *this; }
+	LDKCVec_PublicKeyZ* operator &() { return &self; }
+	LDKCVec_PublicKeyZ* operator ->() { return &self; }
+	const LDKCVec_PublicKeyZ* operator &() const { return &self; }
+	const LDKCVec_PublicKeyZ* operator ->() const { return &self; }
+};
 class C2Tuple_u64u64Z {
 private:
 	LDKC2Tuple_u64u64Z self;
@@ -7769,6 +8203,21 @@ public:
 	const LDKC2Tuple_u64u64Z* operator &() const { return &self; }
 	const LDKC2Tuple_u64u64Z* operator ->() const { return &self; }
 };
+class CResult_RecipientOnionFieldsDecodeErrorZ {
+private:
+	LDKCResult_RecipientOnionFieldsDecodeErrorZ self;
+public:
+	CResult_RecipientOnionFieldsDecodeErrorZ(const CResult_RecipientOnionFieldsDecodeErrorZ&) = delete;
+	CResult_RecipientOnionFieldsDecodeErrorZ(CResult_RecipientOnionFieldsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RecipientOnionFieldsDecodeErrorZ)); }
+	CResult_RecipientOnionFieldsDecodeErrorZ(LDKCResult_RecipientOnionFieldsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RecipientOnionFieldsDecodeErrorZ)); }
+	operator LDKCResult_RecipientOnionFieldsDecodeErrorZ() && { LDKCResult_RecipientOnionFieldsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RecipientOnionFieldsDecodeErrorZ)); return res; }
+	~CResult_RecipientOnionFieldsDecodeErrorZ() { CResult_RecipientOnionFieldsDecodeErrorZ_free(self); }
+	CResult_RecipientOnionFieldsDecodeErrorZ& operator=(CResult_RecipientOnionFieldsDecodeErrorZ&& o) { CResult_RecipientOnionFieldsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RecipientOnionFieldsDecodeErrorZ)); return *this; }
+	LDKCResult_RecipientOnionFieldsDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_RecipientOnionFieldsDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_RecipientOnionFieldsDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_RecipientOnionFieldsDecodeErrorZ* operator ->() const { return &self; }
+};
 class C2Tuple_u32TxOutZ {
 private:
 	LDKC2Tuple_u32TxOutZ self;
@@ -8009,6 +8458,21 @@ public:
 	const LDKCResult_boolPeerHandleErrorZ* operator &() const { return &self; }
 	const LDKCResult_boolPeerHandleErrorZ* operator ->() const { return &self; }
 };
+class CVec_AddressZ {
+private:
+	LDKCVec_AddressZ self;
+public:
+	CVec_AddressZ(const CVec_AddressZ&) = delete;
+	CVec_AddressZ(CVec_AddressZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_AddressZ)); }
+	CVec_AddressZ(LDKCVec_AddressZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_AddressZ)); }
+	operator LDKCVec_AddressZ() && { LDKCVec_AddressZ res = self; memset(&self, 0, sizeof(LDKCVec_AddressZ)); return res; }
+	~CVec_AddressZ() { CVec_AddressZ_free(self); }
+	CVec_AddressZ& operator=(CVec_AddressZ&& o) { CVec_AddressZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_AddressZ)); return *this; }
+	LDKCVec_AddressZ* operator &() { return &self; }
+	LDKCVec_AddressZ* operator ->() { return &self; }
+	const LDKCVec_AddressZ* operator &() const { return &self; }
+	const LDKCVec_AddressZ* operator ->() const { return &self; }
+};
 class CResult_ChannelUpdateDecodeErrorZ {
 private:
 	LDKCResult_ChannelUpdateDecodeErrorZ self;
@@ -8129,6 +8593,21 @@ public:
 	const LDKCOption_NoneZ* operator &() const { return &self; }
 	const LDKCOption_NoneZ* operator ->() const { return &self; }
 };
+class COption_CVec_u8ZZ {
+private:
+	LDKCOption_CVec_u8ZZ self;
+public:
+	COption_CVec_u8ZZ(const COption_CVec_u8ZZ&) = delete;
+	COption_CVec_u8ZZ(COption_CVec_u8ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_CVec_u8ZZ)); }
+	COption_CVec_u8ZZ(LDKCOption_CVec_u8ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_CVec_u8ZZ)); }
+	operator LDKCOption_CVec_u8ZZ() && { LDKCOption_CVec_u8ZZ res = self; memset(&self, 0, sizeof(LDKCOption_CVec_u8ZZ)); return res; }
+	~COption_CVec_u8ZZ() { COption_CVec_u8ZZ_free(self); }
+	COption_CVec_u8ZZ& operator=(COption_CVec_u8ZZ&& o) { COption_CVec_u8ZZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_CVec_u8ZZ)); return *this; }
+	LDKCOption_CVec_u8ZZ* operator &() { return &self; }
+	LDKCOption_CVec_u8ZZ* operator ->() { return &self; }
+	const LDKCOption_CVec_u8ZZ* operator &() const { return &self; }
+	const LDKCOption_CVec_u8ZZ* 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);
@@ -8145,20 +8624,6 @@ inline uint32_t FeeEstimator::get_est_sat_per_1000_weight(enum LDKConfirmationTa
 	uint32_t ret = (self.get_est_sat_per_1000_weight)(self.this_arg, confirmation_target);
 	return ret;
 }
-inline LDK::CVec_MessageSendEventZ MessageSendEventsProvider::get_and_clear_pending_msg_events() {
-	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(struct LDKEvent event) {
-	(self.handle_event)(self.this_arg, event);
-}
 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);
 }
@@ -8203,16 +8668,16 @@ inline uint64_t Score::channel_penalty_msat(uint64_t short_channel_id, const str
 	uint64_t ret = (self.channel_penalty_msat)(self.this_arg, short_channel_id, source, target, usage);
 	return ret;
 }
-inline void Score::payment_path_failed(struct LDKCVec_RouteHopZ path, uint64_t short_channel_id) {
+inline void Score::payment_path_failed(const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id) {
 	(self.payment_path_failed)(self.this_arg, path, short_channel_id);
 }
-inline void Score::payment_path_successful(struct LDKCVec_RouteHopZ path) {
+inline void Score::payment_path_successful(const struct LDKPath *NONNULL_PTR path) {
 	(self.payment_path_successful)(self.this_arg, path);
 }
-inline void Score::probe_failed(struct LDKCVec_RouteHopZ path, uint64_t short_channel_id) {
+inline void Score::probe_failed(const struct LDKPath *NONNULL_PTR 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) {
+inline void Score::probe_successful(const struct LDKPath *NONNULL_PTR path) {
 	(self.probe_successful)(self.this_arg, path);
 }
 inline LDK::Score LockableScore::lock() {
@@ -8223,6 +8688,20 @@ inline uint64_t CustomOnionMessageContents::tlv_type() {
 	uint64_t ret = (self.tlv_type)(self.this_arg);
 	return ret;
 }
+inline LDK::CVec_MessageSendEventZ MessageSendEventsProvider::get_and_clear_pending_msg_events() {
+	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(struct LDKEvent event) {
+	(self.handle_event)(self.this_arg, event);
+}
 inline LDKPublicKey ChannelSigner::get_per_commitment_point(uint64_t idx) {
 	LDKPublicKey ret = (self.get_per_commitment_point)(self.this_arg, idx);
 	return ret;