X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning-c-bindings%2Finclude%2Flightningpp.hpp;h=5092728b2d5dd7985eb7dfd0c7a8a99eca37e43a;hb=18ac1ea0225fcf9d2073c1f7a03b13945572695d;hp=d05c71cda8898f9bd48925f38425be4dda684eaf;hpb=7428d63475aee8fa920405fd14eda47113337798;p=ldk-c-bindings

diff --git a/lightning-c-bindings/include/lightningpp.hpp b/lightning-c-bindings/include/lightningpp.hpp
index d05c71c..5092728 100644
--- a/lightning-c-bindings/include/lightningpp.hpp
+++ b/lightning-c-bindings/include/lightningpp.hpp
@@ -2,6 +2,7 @@
 namespace LDK {
 // Forward declarations
 class Str;
+class CounterpartyCommitmentSecrets;
 class TxCreationKeys;
 class ChannelPublicKeys;
 class HTLCOutputInCommitment;
@@ -20,6 +21,8 @@ class BackgroundProcessor;
 class ChannelManagerPersister;
 class RouteHop;
 class Route;
+class RouteParameters;
+class PaymentParameters;
 class RouteHint;
 class RouteHintHop;
 class BroadcasterInterface;
@@ -42,27 +45,35 @@ class MessageSendEventsProvider;
 class EventsProvider;
 class EventHandler;
 class Score;
+class LockableScore;
+class MultiThreadedLockableScore;
+class FixedPenaltyScorer;
+class Scorer;
+class ScoringParameters;
+class ProbabilisticScoringParameters;
 class InitFeatures;
 class NodeFeatures;
 class ChannelFeatures;
 class InvoiceFeatures;
-class Scorer;
+class ChannelTypeFeatures;
 class DelayedPaymentOutputDescriptor;
 class StaticPaymentOutputDescriptor;
 class SpendableOutputDescriptor;
 class BaseSign;
 class Sign;
+class Recipient;
 class KeysInterface;
 class InMemorySigner;
 class KeysManager;
+class PhantomKeysManager;
 class FilesystemPersister;
-class PaymentId;
 class ChannelManager;
 class ChainParameters;
 class CounterpartyForwardingInfo;
 class ChannelCounterparty;
 class ChannelDetails;
 class PaymentSendFailure;
+class PhantomRouteHints;
 class ChannelManagerReadArgs;
 class ChannelHandshakeConfig;
 class ChannelHandshakeLimits;
@@ -72,6 +83,11 @@ class APIError;
 class OutPoint;
 class CustomMessageReader;
 class Type;
+class InvoicePayer;
+class Payer;
+class Router;
+class RetryAttempts;
+class PaymentError;
 class Invoice;
 class SignedRawInvoice;
 class RawInvoice;
@@ -91,7 +107,6 @@ class CreationError;
 class SemanticError;
 class SignOrCreationError;
 class ChannelMonitorUpdate;
-class MonitorUpdateError;
 class MonitorEvent;
 class HTLCUpdate;
 class Balance;
@@ -108,14 +123,17 @@ class NetworkGraph;
 class ReadOnlyNetworkGraph;
 class NetworkUpdate;
 class NetGraphMsgHandler;
-class DirectionalChannelInfo;
+class ChannelUpdateInfo;
 class ChannelInfo;
+class DirectedChannelInfo;
+class EffectiveCapacity;
 class RoutingFees;
 class NodeAnnouncementInfo;
 class NodeInfo;
 class DecodeError;
 class Init;
 class ErrorMessage;
+class WarningMessage;
 class Ping;
 class Pong;
 class OpenChannel;
@@ -153,17 +171,22 @@ class LightningError;
 class CommitmentUpdate;
 class ChannelMessageHandler;
 class RoutingMessageHandler;
+class DefaultRouter;
 class Level;
+class Record;
 class Logger;
+class MonitorUpdateId;
 class Persist;
 class LockedChannelMonitor;
 class ChainMonitor;
 class CVec_SpendableOutputDescriptorZ;
 class CResult_LockedChannelMonitorNoneZ;
+class CResult_PhantomRouteHintsDecodeErrorZ;
 class CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ;
-class CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ;
+class CResult_ScoringParametersDecodeErrorZ;
 class CResult_HTLCUpdateDecodeErrorZ;
 class C2Tuple_SignatureCVec_SignatureZZ;
+class CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ;
 class CVec_C2Tuple_u32TxOutZZ;
 class CResult_ChannelInfoDecodeErrorZ;
 class CResult_FundingCreatedDecodeErrorZ;
@@ -176,32 +199,33 @@ class COption_NetworkUpdateZ;
 class COption_u64Z;
 class CResult_TxOutAccessErrorZ;
 class CResult_TrustedClosingTransactionNoneZ;
+class CResult_PaymentPreimageAPIErrorZ;
 class CResult_ChannelMonitorUpdateDecodeErrorZ;
+class CResult_RouteHintDecodeErrorZ;
 class C2Tuple_PublicKeyTypeZ;
 class CResult_NetAddressDecodeErrorZ;
 class CResult_ChannelReestablishDecodeErrorZ;
-class CResult_UnsignedNodeAnnouncementDecodeErrorZ;
-class CResult_ReplyChannelRangeDecodeErrorZ;
 class CResult_CommitmentSignedDecodeErrorZ;
 class CVec_UpdateAddHTLCZ;
-class CResult_GossipTimestampFilterDecodeErrorZ;
+class CResult_UnsignedNodeAnnouncementDecodeErrorZ;
 class COption_u32Z;
 class CResult_InitFeaturesDecodeErrorZ;
 class CResult_StaticPaymentOutputDescriptorDecodeErrorZ;
 class CResult_PaymentIdPaymentSendFailureZ;
-class CResult_InvoiceSignOrCreationErrorZ;
+class CResult_ReplyChannelRangeDecodeErrorZ;
 class CResult_CommitmentTransactionDecodeErrorZ;
 class COption_C2Tuple_usizeTransactionZZ;
 class CResult_TransactionNoneZ;
 class CResult_SignedRawInvoiceNoneZ;
-class CResult_ExpiryTimeCreationErrorZ;
 class CResult_ClosingSignedFeeRangeDecodeErrorZ;
 class CResult_PingDecodeErrorZ;
-class COption_FilterZ;
+class CResult_GossipTimestampFilterDecodeErrorZ;
+class CResult_InvoiceSignOrCreationErrorZ;
 class CVec_TransactionOutputsZ;
 class CResult_ErrorMessageDecodeErrorZ;
 class CResult_OpenChannelDecodeErrorZ;
 class CVec_CVec_u8ZZ;
+class COption_FilterZ;
 class CResult_SecretKeyErrorZ;
 class CResult_ShutdownScriptDecodeErrorZ;
 class CResult_InvoiceNoneZ;
@@ -222,8 +246,8 @@ class C2Tuple_BlockHashChannelMonitorZ;
 class CResult_NodeIdDecodeErrorZ;
 class CResult_ShutdownScriptInvalidShutdownScriptZ;
 class CResult_RecoverableSignatureNoneZ;
+class CResult_COption_NetworkUpdateZDecodeErrorZ;
 class CResult_NodeAnnouncementInfoDecodeErrorZ;
-class CResult_NetAddressu8Z;
 class C3Tuple_RawInvoice_u832InvoiceSignatureZ;
 class CVec_UpdateFailMalformedHTLCZ;
 class CResult_FundingSignedDecodeErrorZ;
@@ -238,64 +262,83 @@ class CResult_NodeInfoDecodeErrorZ;
 class CResult_ClosingSignedDecodeErrorZ;
 class CResult_HolderCommitmentTransactionDecodeErrorZ;
 class CVec_CResult_NoneAPIErrorZZ;
+class CResult_CounterpartyCommitmentSecretsDecodeErrorZ;
+class CResult_ChannelCounterpartyDecodeErrorZ;
+class CResult_WarningMessageDecodeErrorZ;
 class CResult_SignatureNoneZ;
+class CVec_RouteHintHopZ;
+class CResult_SecretKeyNoneZ;
+class CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ;
 class C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ;
+class CResult_PaymentParametersDecodeErrorZ;
 class CResult_InitDecodeErrorZ;
 class CResult_OutPointDecodeErrorZ;
 class CVec_ChannelDetailsZ;
 class CResult_SignDecodeErrorZ;
 class CVec_MessageSendEventZ;
 class C2Tuple_OutPointScriptZ;
-class CResult_PaymentIdDecodeErrorZ;
-class CResult_UpdateFailMalformedHTLCDecodeErrorZ;
+class CResult_RouteHintHopDecodeErrorZ;
+class CResult_C2Tuple_SignatureSignatureZNoneZ;
 class CVec_NodeAnnouncementZ;
+class CResult_UpdateFailMalformedHTLCDecodeErrorZ;
 class CResult_UnsignedChannelAnnouncementDecodeErrorZ;
 class CVec_TxidZ;
-class CResult_NoneMonitorUpdateErrorZ;
+class COption_AccessZ;
 class CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ;
 class CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ;
 class CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ;
 class CResult_CVec_CVec_u8ZZNoneZ;
+class C2Tuple_SignatureSignatureZ;
 class C2Tuple_PaymentHashPaymentSecretZ;
-class COption_AccessZ;
 class C2Tuple_BlockHashChannelManagerZ;
 class CResult_ChannelTransactionParametersDecodeErrorZ;
 class CResult_AcceptChannelDecodeErrorZ;
 class CVec_SignatureZ;
 class CVec_u64Z;
-class CResult_PongDecodeErrorZ;
+class CResult_ScorerDecodeErrorZ;
 class CResult_DelayedPaymentOutputDescriptorDecodeErrorZ;
 class C2Tuple_PaymentHashPaymentIdZ;
-class CResult_StringErrorZ;
+class CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ;
 class CResult_NoneErrorZ;
+class CResult_StringErrorZ;
 class C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ;
+class CResult_PongDecodeErrorZ;
 class CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ;
+class COption_EventZ;
+class CResult_ChannelTypeFeaturesDecodeErrorZ;
 class CVec_RouteHintZ;
 class COption_u16Z;
 class CVec_CVec_RouteHopZZ;
 class CResult_TrustedCommitmentTransactionNoneZ;
+class CResult_FixedPenaltyScorerDecodeErrorZ;
 class CResult_NoneLightningErrorZ;
 class CResult_NonePeerHandleErrorZ;
-class COption_CVec_NetAddressZZ;
+class CResult_COption_EventZDecodeErrorZ;
 class CResult_CVec_SignatureZNoneZ;
+class COption_CVec_NetAddressZZ;
 class CResult__u832APIErrorZ;
+class CResult_PaymentIdPaymentErrorZ;
 class CResult_DescriptionCreationErrorZ;
+class CResult_COption_MonitorEventZDecodeErrorZ;
+class CResult_PayeePubKeyErrorZ;
 class CVec_C2Tuple_PublicKeyTypeZZ;
 class CResult_RoutingFeesDecodeErrorZ;
-class CResult_PayeePubKeyErrorZ;
 class CResult_QueryShortChannelIdsDecodeErrorZ;
 class CResult_InvoiceSemanticErrorZ;
 class CResult_UpdateAddHTLCDecodeErrorZ;
+class CVec_PhantomRouteHintsZ;
 class CResult_CounterpartyChannelTransactionParametersDecodeErrorZ;
 class CResult_NoneAPIErrorZ;
 class CVec_NetAddressZ;
+class CResult_ChannelDetailsDecodeErrorZ;
 class CVec_C2Tuple_usizeTransactionZZ;
 class CVec_PublicKeyZ;
+class COption_MonitorEventZ;
 class COption_TypeZ;
 class CResult_COption_TypeZDecodeErrorZ;
-class CResult_DirectionalChannelInfoDecodeErrorZ;
 class C2Tuple_u32TxOutZ;
 class CResult_UpdateFailHTLCDecodeErrorZ;
+class CResult_PaymentSecretNoneZ;
 class CResult_ChannelConfigDecodeErrorZ;
 class CVec_PrivateRouteZ;
 class CResult_SpendableOutputDescriptorDecodeErrorZ;
@@ -305,29 +348,37 @@ class CResult_ShutdownDecodeErrorZ;
 class CVec_EventZ;
 class CResult_NoneSemanticErrorZ;
 class CVec_MonitorEventZ;
+class CVec_PaymentPreimageZ;
 class CVec_C2Tuple_u32ScriptZZ;
 class CResult_NoneChannelMonitorUpdateErrZ;
+class CResult_COption_ClosureReasonZDecodeErrorZ;
 class CResult_SiPrefixNoneZ;
 class CResult_PublicKeyErrorZ;
 class C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ;
 class CResult_NoneNoneZ;
+class CResult_RouteParametersDecodeErrorZ;
+class COption_ClosureReasonZ;
+class CVec_APIErrorZ;
 class CResult_PrivateRouteCreationErrorZ;
 class CResult_boolPeerHandleErrorZ;
-class CVec_APIErrorZ;
 class CResult_ChannelUpdateDecodeErrorZ;
 class CVec_UpdateFulfillHTLCZ;
 class CResult_AnnouncementSignaturesDecodeErrorZ;
 class CResult_UpdateFulfillHTLCDecodeErrorZ;
 class CResult_NodeFeaturesDecodeErrorZ;
+class CVec_u5Z;
 class CResult_InMemorySignerDecodeErrorZ;
 class CResult_PaymentSecretAPIErrorZ;
+class CResult_CounterpartyForwardingInfoDecodeErrorZ;
 class C2Tuple_u32ScriptZ;
-class CResult_CResult_NetAddressu8ZDecodeErrorZ;
 class CResult_ReplyShortChannelIdsEndDecodeErrorZ;
 class CResult_RouteDecodeErrorZ;
 class CResult_BuiltCommitmentTransactionDecodeErrorZ;
-class CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ;
+class COption_NoneZ;
 class CVec_TxOutZ;
+class CResult_ProbabilisticScoringParametersDecodeErrorZ;
+class CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ;
+class CResult_ChannelUpdateInfoDecodeErrorZ;
 class CVec_UpdateFailHTLCZ;
 class CResult_FundingLockedDecodeErrorZ;
 
@@ -346,6 +397,21 @@ public:
 	const LDKStr* operator &() const { return &self; }
 	const LDKStr* operator ->() const { return &self; }
 };
+class CounterpartyCommitmentSecrets {
+private:
+	LDKCounterpartyCommitmentSecrets self;
+public:
+	CounterpartyCommitmentSecrets(const CounterpartyCommitmentSecrets&) = delete;
+	CounterpartyCommitmentSecrets(CounterpartyCommitmentSecrets&& o) : self(o.self) { memset(&o, 0, sizeof(CounterpartyCommitmentSecrets)); }
+	CounterpartyCommitmentSecrets(LDKCounterpartyCommitmentSecrets&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCounterpartyCommitmentSecrets)); }
+	operator LDKCounterpartyCommitmentSecrets() && { LDKCounterpartyCommitmentSecrets res = self; memset(&self, 0, sizeof(LDKCounterpartyCommitmentSecrets)); return res; }
+	~CounterpartyCommitmentSecrets() { CounterpartyCommitmentSecrets_free(self); }
+	CounterpartyCommitmentSecrets& operator=(CounterpartyCommitmentSecrets&& o) { CounterpartyCommitmentSecrets_free(self); self = o.self; memset(&o, 0, sizeof(CounterpartyCommitmentSecrets)); return *this; }
+	LDKCounterpartyCommitmentSecrets* operator &() { return &self; }
+	LDKCounterpartyCommitmentSecrets* operator ->() { return &self; }
+	const LDKCounterpartyCommitmentSecrets* operator &() const { return &self; }
+	const LDKCounterpartyCommitmentSecrets* operator ->() const { return &self; }
+};
 class TxCreationKeys {
 private:
 	LDKTxCreationKeys self;
@@ -623,6 +689,36 @@ public:
 	const LDKRoute* operator &() const { return &self; }
 	const LDKRoute* operator ->() const { return &self; }
 };
+class RouteParameters {
+private:
+	LDKRouteParameters self;
+public:
+	RouteParameters(const RouteParameters&) = delete;
+	RouteParameters(RouteParameters&& o) : self(o.self) { memset(&o, 0, sizeof(RouteParameters)); }
+	RouteParameters(LDKRouteParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteParameters)); }
+	operator LDKRouteParameters() && { LDKRouteParameters res = self; memset(&self, 0, sizeof(LDKRouteParameters)); return res; }
+	~RouteParameters() { RouteParameters_free(self); }
+	RouteParameters& operator=(RouteParameters&& o) { RouteParameters_free(self); self = o.self; memset(&o, 0, sizeof(RouteParameters)); return *this; }
+	LDKRouteParameters* operator &() { return &self; }
+	LDKRouteParameters* operator ->() { return &self; }
+	const LDKRouteParameters* operator &() const { return &self; }
+	const LDKRouteParameters* operator ->() const { return &self; }
+};
+class PaymentParameters {
+private:
+	LDKPaymentParameters self;
+public:
+	PaymentParameters(const PaymentParameters&) = delete;
+	PaymentParameters(PaymentParameters&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentParameters)); }
+	PaymentParameters(LDKPaymentParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentParameters)); }
+	operator LDKPaymentParameters() && { LDKPaymentParameters res = self; memset(&self, 0, sizeof(LDKPaymentParameters)); return res; }
+	~PaymentParameters() { PaymentParameters_free(self); }
+	PaymentParameters& operator=(PaymentParameters&& o) { PaymentParameters_free(self); self = o.self; memset(&o, 0, sizeof(PaymentParameters)); return *this; }
+	LDKPaymentParameters* operator &() { return &self; }
+	LDKPaymentParameters* operator ->() { return &self; }
+	const LDKPaymentParameters* operator &() const { return &self; }
+	const LDKPaymentParameters* operator ->() const { return &self; }
+};
 class RouteHint {
 private:
 	LDKRouteHint self;
@@ -703,12 +799,12 @@ public:
 	/**
 	 *  Gets estimated satoshis of fee required per 1000 Weight-Units.
 	 * 
-	 *  Must be no smaller than 253 (ie 1 satoshi-per-byte rounded up to ensure later round-downs
-	 *  don't put us below 1 satoshi-per-byte).
+	 *  Must return a value no smaller than 253 (ie 1 satoshi-per-byte rounded up to ensure later
+	 *  round-downs don't put us below 1 satoshi-per-byte).
 	 * 
-	 *  This translates to:
-	 *   * satoshis-per-byte * 250
-	 *   * ceil(satoshis-per-kbyte / 4)
+	 *  This method can be implemented with the following unit conversions:
+	 *   * max(satoshis-per-byte * 250, 253)
+	 *   * max(satoshis-per-kbyte / 4, 253)
 	 */
 	inline uint32_t get_est_sat_per_1000_weight(enum LDKConfirmationTarget confirmation_target);
 };
@@ -907,6 +1003,13 @@ public:
 	/**
 	 *  Returns any monitor events since the last call. Subsequent calls must only return new
 	 *  events.
+	 * 
+	 *  Note that after any block- or transaction-connection calls to a [`ChannelMonitor`], no
+	 *  further events may be returned here until the [`ChannelMonitor`] has been fully persisted
+	 *  to disk.
+	 * 
+	 *  For details on asynchronous [`ChannelMonitor`] updating and returning
+	 *  [`MonitorEvent::UpdateCompleted`] here, see [`ChannelMonitorUpdateErr::TemporaryFailure`].
 	 */
 	inline LDK::CVec_MonitorEventZ release_pending_monitor_events();
 };
@@ -1096,9 +1199,118 @@ public:
 	const LDKScore* operator &() const { return &self; }
 	const LDKScore* operator ->() const { return &self; }
 	/**
-	 *  Returns the fee in msats willing to be paid to avoid routing through the given channel.
+	 *  Returns the fee in msats willing to be paid to avoid routing `send_amt_msat` through the
+	 *  given channel in the direction from `source` to `target`.
+	 * 
+	 *  The channel's capacity (less any other MPP parts that are also being considered for use in
+	 *  the same payment) is given by `capacity_msat`. It may be determined from various sources
+	 *  such as a chain data, network gossip, or invoice hints. For invoice hints, a capacity near
+	 *  [`u64::max_value`] is given to indicate sufficient capacity for the invoice's full amount.
+	 *  Thus, implementations should be overflow-safe.
+	 */
+	inline uint64_t channel_penalty_msat(uint64_t short_channel_id, uint64_t send_amt_msat, uint64_t capacity_msat, const struct LDKNodeId *NONNULL_PTR source, const struct LDKNodeId *NONNULL_PTR target);
+	/**
+	 *  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);
+	/**
+	 *  Handles updating channel penalties after successfully routing along a path.
+	 */
+	inline void payment_path_successful(struct LDKCVec_RouteHopZ path);
+};
+class LockableScore {
+private:
+	LDKLockableScore self;
+public:
+	LockableScore(const LockableScore&) = delete;
+	LockableScore(LockableScore&& o) : self(o.self) { memset(&o, 0, sizeof(LockableScore)); }
+	LockableScore(LDKLockableScore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLockableScore)); }
+	operator LDKLockableScore() && { LDKLockableScore res = self; memset(&self, 0, sizeof(LDKLockableScore)); return res; }
+	~LockableScore() { LockableScore_free(self); }
+	LockableScore& operator=(LockableScore&& o) { LockableScore_free(self); self = o.self; memset(&o, 0, sizeof(LockableScore)); return *this; }
+	LDKLockableScore* operator &() { return &self; }
+	LDKLockableScore* operator ->() { return &self; }
+	const LDKLockableScore* operator &() const { return &self; }
+	const LDKLockableScore* operator ->() const { return &self; }
+	/**
+	 *  Returns the locked scorer.
 	 */
-	inline uint64_t channel_penalty_msat(uint64_t short_channel_id);
+	inline LDK::Score lock();
+};
+class MultiThreadedLockableScore {
+private:
+	LDKMultiThreadedLockableScore self;
+public:
+	MultiThreadedLockableScore(const MultiThreadedLockableScore&) = delete;
+	MultiThreadedLockableScore(MultiThreadedLockableScore&& o) : self(o.self) { memset(&o, 0, sizeof(MultiThreadedLockableScore)); }
+	MultiThreadedLockableScore(LDKMultiThreadedLockableScore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMultiThreadedLockableScore)); }
+	operator LDKMultiThreadedLockableScore() && { LDKMultiThreadedLockableScore res = self; memset(&self, 0, sizeof(LDKMultiThreadedLockableScore)); return res; }
+	~MultiThreadedLockableScore() { MultiThreadedLockableScore_free(self); }
+	MultiThreadedLockableScore& operator=(MultiThreadedLockableScore&& o) { MultiThreadedLockableScore_free(self); self = o.self; memset(&o, 0, sizeof(MultiThreadedLockableScore)); return *this; }
+	LDKMultiThreadedLockableScore* operator &() { return &self; }
+	LDKMultiThreadedLockableScore* operator ->() { return &self; }
+	const LDKMultiThreadedLockableScore* operator &() const { return &self; }
+	const LDKMultiThreadedLockableScore* operator ->() const { return &self; }
+};
+class FixedPenaltyScorer {
+private:
+	LDKFixedPenaltyScorer self;
+public:
+	FixedPenaltyScorer(const FixedPenaltyScorer&) = delete;
+	FixedPenaltyScorer(FixedPenaltyScorer&& o) : self(o.self) { memset(&o, 0, sizeof(FixedPenaltyScorer)); }
+	FixedPenaltyScorer(LDKFixedPenaltyScorer&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFixedPenaltyScorer)); }
+	operator LDKFixedPenaltyScorer() && { LDKFixedPenaltyScorer res = self; memset(&self, 0, sizeof(LDKFixedPenaltyScorer)); return res; }
+	~FixedPenaltyScorer() { FixedPenaltyScorer_free(self); }
+	FixedPenaltyScorer& operator=(FixedPenaltyScorer&& o) { FixedPenaltyScorer_free(self); self = o.self; memset(&o, 0, sizeof(FixedPenaltyScorer)); return *this; }
+	LDKFixedPenaltyScorer* operator &() { return &self; }
+	LDKFixedPenaltyScorer* operator ->() { return &self; }
+	const LDKFixedPenaltyScorer* operator &() const { return &self; }
+	const LDKFixedPenaltyScorer* operator ->() const { return &self; }
+};
+class Scorer {
+private:
+	LDKScorer self;
+public:
+	Scorer(const Scorer&) = delete;
+	Scorer(Scorer&& o) : self(o.self) { memset(&o, 0, sizeof(Scorer)); }
+	Scorer(LDKScorer&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKScorer)); }
+	operator LDKScorer() && { LDKScorer res = self; memset(&self, 0, sizeof(LDKScorer)); return res; }
+	~Scorer() { Scorer_free(self); }
+	Scorer& operator=(Scorer&& o) { Scorer_free(self); self = o.self; memset(&o, 0, sizeof(Scorer)); return *this; }
+	LDKScorer* operator &() { return &self; }
+	LDKScorer* operator ->() { return &self; }
+	const LDKScorer* operator &() const { return &self; }
+	const LDKScorer* operator ->() const { return &self; }
+};
+class ScoringParameters {
+private:
+	LDKScoringParameters self;
+public:
+	ScoringParameters(const ScoringParameters&) = delete;
+	ScoringParameters(ScoringParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ScoringParameters)); }
+	ScoringParameters(LDKScoringParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKScoringParameters)); }
+	operator LDKScoringParameters() && { LDKScoringParameters res = self; memset(&self, 0, sizeof(LDKScoringParameters)); return res; }
+	~ScoringParameters() { ScoringParameters_free(self); }
+	ScoringParameters& operator=(ScoringParameters&& o) { ScoringParameters_free(self); self = o.self; memset(&o, 0, sizeof(ScoringParameters)); return *this; }
+	LDKScoringParameters* operator &() { return &self; }
+	LDKScoringParameters* operator ->() { return &self; }
+	const LDKScoringParameters* operator &() const { return &self; }
+	const LDKScoringParameters* operator ->() const { return &self; }
+};
+class ProbabilisticScoringParameters {
+private:
+	LDKProbabilisticScoringParameters self;
+public:
+	ProbabilisticScoringParameters(const ProbabilisticScoringParameters&) = delete;
+	ProbabilisticScoringParameters(ProbabilisticScoringParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ProbabilisticScoringParameters)); }
+	ProbabilisticScoringParameters(LDKProbabilisticScoringParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKProbabilisticScoringParameters)); }
+	operator LDKProbabilisticScoringParameters() && { LDKProbabilisticScoringParameters res = self; memset(&self, 0, sizeof(LDKProbabilisticScoringParameters)); return res; }
+	~ProbabilisticScoringParameters() { ProbabilisticScoringParameters_free(self); }
+	ProbabilisticScoringParameters& operator=(ProbabilisticScoringParameters&& o) { ProbabilisticScoringParameters_free(self); self = o.self; memset(&o, 0, sizeof(ProbabilisticScoringParameters)); return *this; }
+	LDKProbabilisticScoringParameters* operator &() { return &self; }
+	LDKProbabilisticScoringParameters* operator ->() { return &self; }
+	const LDKProbabilisticScoringParameters* operator &() const { return &self; }
+	const LDKProbabilisticScoringParameters* operator ->() const { return &self; }
 };
 class InitFeatures {
 private:
@@ -1160,20 +1372,20 @@ public:
 	const LDKInvoiceFeatures* operator &() const { return &self; }
 	const LDKInvoiceFeatures* operator ->() const { return &self; }
 };
-class Scorer {
+class ChannelTypeFeatures {
 private:
-	LDKScorer self;
+	LDKChannelTypeFeatures self;
 public:
-	Scorer(const Scorer&) = delete;
-	Scorer(Scorer&& o) : self(o.self) { memset(&o, 0, sizeof(Scorer)); }
-	Scorer(LDKScorer&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKScorer)); }
-	operator LDKScorer() && { LDKScorer res = self; memset(&self, 0, sizeof(LDKScorer)); return res; }
-	~Scorer() { Scorer_free(self); }
-	Scorer& operator=(Scorer&& o) { Scorer_free(self); self = o.self; memset(&o, 0, sizeof(Scorer)); return *this; }
-	LDKScorer* operator &() { return &self; }
-	LDKScorer* operator ->() { return &self; }
-	const LDKScorer* operator &() const { return &self; }
-	const LDKScorer* operator ->() const { return &self; }
+	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 DelayedPaymentOutputDescriptor {
 private:
@@ -1258,8 +1470,15 @@ public:
 	 *  secret won't leave us without a broadcastable holder transaction.
 	 *  Policy checks should be implemented in this function, including checking the amount
 	 *  sent to us and checking the HTLCs.
+	 * 
+	 *  The preimages of outgoing HTLCs that were fulfilled since the last commitment are provided.
+	 *  A validating signer should ensure that an HTLC output is removed only when the matching
+	 *  preimage is provided, or when the value to holder is restored.
+	 * 
+	 *  NOTE: all the relevant preimages will be provided, but there may also be additional
+	 *  irrelevant or duplicate preimages.
 	 */
-	inline LDK::CResult_NoneNoneZ validate_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx);
+	inline LDK::CResult_NoneNoneZ validate_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_PaymentPreimageZ preimages);
 	/**
 	 *  Gets an arbitrary identifier describing the set of keys which are provided back to you in
 	 *  some SpendableOutputDescriptor types. This should be sufficient to identify this
@@ -1273,8 +1492,15 @@ public:
 	 * 
 	 *  Policy checks should be implemented in this function, including checking the amount
 	 *  sent to us and checking the HTLCs.
+	 * 
+	 *  The preimages of outgoing HTLCs that were fulfilled since the last commitment are provided.
+	 *  A validating signer should ensure that an HTLC output is removed only when the matching
+	 *  preimage is provided, or when the value to holder is restored.
+	 * 
+	 *  NOTE: all the relevant preimages will be provided, but there may also be additional
+	 *  irrelevant or duplicate preimages.
 	 */
-	inline LDK::CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ sign_counterparty_commitment(const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx);
+	inline LDK::CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ sign_counterparty_commitment(const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx, struct LDKCVec_PaymentPreimageZ preimages);
 	/**
 	 *  Validate the counterparty's revocation.
 	 * 
@@ -1361,14 +1587,17 @@ public:
 	 */
 	inline LDK::CResult_SignatureNoneZ sign_closing_transaction(const struct LDKClosingTransaction *NONNULL_PTR closing_tx);
 	/**
-	 *  Signs a channel announcement message with our funding key, proving it comes from one
-	 *  of the channel participants.
+	 *  Signs a channel announcement message with our funding key and our node secret key (aka
+	 *  node_id or network_key), proving it comes from one of the channel participants.
+	 * 
+	 *  The first returned signature should be from our node secret key, the second from our
+	 *  funding key.
 	 * 
 	 *  Note that if this fails or is rejected, the channel will not be publicly announced and
 	 *  our counterparty may (though likely will not) close the channel on us for violating the
 	 *  protocol.
 	 */
-	inline LDK::CResult_SignatureNoneZ sign_channel_announcement(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg);
+	inline LDK::CResult_C2Tuple_SignatureSignatureZNoneZ sign_channel_announcement(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg);
 	/**
 	 *  Set the counterparty static channel data, including basepoints,
 	 *  counterparty_selected/holder_selected_contest_delay and funding outpoint.
@@ -1398,6 +1627,20 @@ public:
 	const LDKSign* operator &() const { return &self; }
 	const LDKSign* operator ->() const { return &self; }
 };
+class Recipient {
+private:
+	LDKRecipient self;
+public:
+	Recipient(const Recipient&) = delete;
+	Recipient(Recipient&& o) : self(o.self) { memset(&o, 0, sizeof(Recipient)); }
+	Recipient(LDKRecipient&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRecipient)); }
+	operator LDKRecipient() && { LDKRecipient res = self; memset(&self, 0, sizeof(LDKRecipient)); return res; }
+	Recipient& operator=(Recipient&& o) { self = o.self; memset(&o, 0, sizeof(Recipient)); return *this; }
+	LDKRecipient* operator &() { return &self; }
+	LDKRecipient* operator ->() { return &self; }
+	const LDKRecipient* operator &() const { return &self; }
+	const LDKRecipient* operator ->() const { return &self; }
+};
 class KeysInterface {
 private:
 	LDKKeysInterface self;
@@ -1413,11 +1656,12 @@ public:
 	const LDKKeysInterface* operator &() const { return &self; }
 	const LDKKeysInterface* operator ->() const { return &self; }
 	/**
-	 *  Get node secret key (aka node_id or network_key).
+	 *  Get node secret key (aka node_id or network_key) based on the provided [`Recipient`].
 	 * 
-	 *  This method must return the same value each time it is called.
+	 *  This method must return the same value each time it is called with a given `Recipient`
+	 *  parameter.
 	 */
-	inline LDKSecretKey get_node_secret();
+	inline LDK::CResult_SecretKeyNoneZ get_node_secret(enum LDKRecipient recipient);
 	/**
 	 *  Get a script pubkey which we send funds to when claiming on-chain contestable outputs.
 	 * 
@@ -1457,12 +1701,27 @@ public:
 	 */
 	inline LDK::CResult_SignDecodeErrorZ read_chan_signer(struct LDKu8slice reader);
 	/**
-	 *  Sign an invoice's preimage (note that this is the preimage of the invoice, not the HTLC's
-	 *  preimage). By parameterizing by the preimage instead of the hash, we allow implementors of
+	 *  Sign an invoice.
+	 *  By parameterizing by the raw invoice bytes instead of the hash, we allow implementors of
 	 *  this trait to parse the invoice and make sure they're signing what they expect, rather than
 	 *  blindly signing the hash.
+	 *  The hrp is ascii bytes, while the invoice data is base32.
+	 * 
+	 *  The secret key used to sign the invoice is dependent on the [`Recipient`].
+	 */
+	inline LDK::CResult_RecoverableSignatureNoneZ sign_invoice(struct LDKu8slice hrp_bytes, struct LDKCVec_u5Z invoice_data, enum LDKRecipient receipient);
+	/**
+	 *  Get secret key material as bytes for use in encrypting and decrypting inbound payment data.
+	 * 
+	 *  If the implementor of this trait supports [phantom node payments], then every node that is
+	 *  intended to be included in the phantom invoice route hints must return the same value from
+	 *  this method.
+	 * 
+	 *  This method must return the same value each time it is called.
+	 * 
+	 *  [phantom node payments]: PhantomKeysManager
 	 */
-	inline LDK::CResult_RecoverableSignatureNoneZ sign_invoice(struct LDKCVec_u8Z invoice_preimage);
+	inline LDKThirtyTwoBytes get_inbound_payment_key_material();
 };
 class InMemorySigner {
 private:
@@ -1494,6 +1753,21 @@ public:
 	const LDKKeysManager* operator &() const { return &self; }
 	const LDKKeysManager* operator ->() const { return &self; }
 };
+class PhantomKeysManager {
+private:
+	LDKPhantomKeysManager self;
+public:
+	PhantomKeysManager(const PhantomKeysManager&) = delete;
+	PhantomKeysManager(PhantomKeysManager&& o) : self(o.self) { memset(&o, 0, sizeof(PhantomKeysManager)); }
+	PhantomKeysManager(LDKPhantomKeysManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPhantomKeysManager)); }
+	operator LDKPhantomKeysManager() && { LDKPhantomKeysManager res = self; memset(&self, 0, sizeof(LDKPhantomKeysManager)); return res; }
+	~PhantomKeysManager() { PhantomKeysManager_free(self); }
+	PhantomKeysManager& operator=(PhantomKeysManager&& o) { PhantomKeysManager_free(self); self = o.self; memset(&o, 0, sizeof(PhantomKeysManager)); return *this; }
+	LDKPhantomKeysManager* operator &() { return &self; }
+	LDKPhantomKeysManager* operator ->() { return &self; }
+	const LDKPhantomKeysManager* operator &() const { return &self; }
+	const LDKPhantomKeysManager* operator ->() const { return &self; }
+};
 class FilesystemPersister {
 private:
 	LDKFilesystemPersister self;
@@ -1509,21 +1783,6 @@ public:
 	const LDKFilesystemPersister* operator &() const { return &self; }
 	const LDKFilesystemPersister* operator ->() const { return &self; }
 };
-class PaymentId {
-private:
-	LDKPaymentId self;
-public:
-	PaymentId(const PaymentId&) = delete;
-	PaymentId(PaymentId&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentId)); }
-	PaymentId(LDKPaymentId&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentId)); }
-	operator LDKPaymentId() && { LDKPaymentId res = self; memset(&self, 0, sizeof(LDKPaymentId)); return res; }
-	~PaymentId() { PaymentId_free(self); }
-	PaymentId& operator=(PaymentId&& o) { PaymentId_free(self); self = o.self; memset(&o, 0, sizeof(PaymentId)); return *this; }
-	LDKPaymentId* operator &() { return &self; }
-	LDKPaymentId* operator ->() { return &self; }
-	const LDKPaymentId* operator &() const { return &self; }
-	const LDKPaymentId* operator ->() const { return &self; }
-};
 class ChannelManager {
 private:
 	LDKChannelManager self;
@@ -1614,6 +1873,21 @@ public:
 	const LDKPaymentSendFailure* operator &() const { return &self; }
 	const LDKPaymentSendFailure* operator ->() const { return &self; }
 };
+class PhantomRouteHints {
+private:
+	LDKPhantomRouteHints self;
+public:
+	PhantomRouteHints(const PhantomRouteHints&) = delete;
+	PhantomRouteHints(PhantomRouteHints&& o) : self(o.self) { memset(&o, 0, sizeof(PhantomRouteHints)); }
+	PhantomRouteHints(LDKPhantomRouteHints&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPhantomRouteHints)); }
+	operator LDKPhantomRouteHints() && { LDKPhantomRouteHints res = self; memset(&self, 0, sizeof(LDKPhantomRouteHints)); return res; }
+	~PhantomRouteHints() { PhantomRouteHints_free(self); }
+	PhantomRouteHints& operator=(PhantomRouteHints&& o) { PhantomRouteHints_free(self); self = o.self; memset(&o, 0, sizeof(PhantomRouteHints)); return *this; }
+	LDKPhantomRouteHints* operator &() { return &self; }
+	LDKPhantomRouteHints* operator ->() { return &self; }
+	const LDKPhantomRouteHints* operator &() const { return &self; }
+	const LDKPhantomRouteHints* operator ->() const { return &self; }
+};
 class ChannelManagerReadArgs {
 private:
 	LDKChannelManagerReadArgs self;
@@ -1764,6 +2038,113 @@ public:
 	 */
 	inline LDK::Str debug_str();
 };
+class InvoicePayer {
+private:
+	LDKInvoicePayer self;
+public:
+	InvoicePayer(const InvoicePayer&) = delete;
+	InvoicePayer(InvoicePayer&& o) : self(o.self) { memset(&o, 0, sizeof(InvoicePayer)); }
+	InvoicePayer(LDKInvoicePayer&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoicePayer)); }
+	operator LDKInvoicePayer() && { LDKInvoicePayer res = self; memset(&self, 0, sizeof(LDKInvoicePayer)); return res; }
+	~InvoicePayer() { InvoicePayer_free(self); }
+	InvoicePayer& operator=(InvoicePayer&& o) { InvoicePayer_free(self); self = o.self; memset(&o, 0, sizeof(InvoicePayer)); return *this; }
+	LDKInvoicePayer* operator &() { return &self; }
+	LDKInvoicePayer* operator ->() { return &self; }
+	const LDKInvoicePayer* operator &() const { return &self; }
+	const LDKInvoicePayer* operator ->() const { return &self; }
+};
+class Payer {
+private:
+	LDKPayer self;
+public:
+	Payer(const Payer&) = delete;
+	Payer(Payer&& o) : self(o.self) { memset(&o, 0, sizeof(Payer)); }
+	Payer(LDKPayer&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPayer)); }
+	operator LDKPayer() && { LDKPayer res = self; memset(&self, 0, sizeof(LDKPayer)); return res; }
+	~Payer() { Payer_free(self); }
+	Payer& operator=(Payer&& o) { Payer_free(self); self = o.self; memset(&o, 0, sizeof(Payer)); return *this; }
+	LDKPayer* operator &() { return &self; }
+	LDKPayer* operator ->() { return &self; }
+	const LDKPayer* operator &() const { return &self; }
+	const LDKPayer* operator ->() const { return &self; }
+	/**
+	 *  Returns the payer's node id.
+	 */
+	inline LDKPublicKey node_id();
+	/**
+	 *  Returns the payer's channels.
+	 */
+	inline LDK::CVec_ChannelDetailsZ first_hops();
+	/**
+	 *  Sends a payment over the Lightning Network using the given [`Route`].
+	 * 
+	 *  Note that payment_secret (or a relevant inner pointer) may be NULL or all-0s to represent None
+	 */
+	inline LDK::CResult_PaymentIdPaymentSendFailureZ send_payment(const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_hash, struct LDKThirtyTwoBytes payment_secret);
+	/**
+	 *  Sends a spontaneous payment over the Lightning Network using the given [`Route`].
+	 */
+	inline LDK::CResult_PaymentIdPaymentSendFailureZ send_spontaneous_payment(const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_preimage);
+	/**
+	 *  Retries a failed payment path for the [`PaymentId`] using the given [`Route`].
+	 */
+	inline LDK::CResult_NonePaymentSendFailureZ retry_payment(const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_id);
+	/**
+	 *  Signals that no further retries for the given payment will occur.
+	 */
+	inline void abandon_payment(struct LDKThirtyTwoBytes payment_id);
+};
+class Router {
+private:
+	LDKRouter self;
+public:
+	Router(const Router&) = delete;
+	Router(Router&& o) : self(o.self) { memset(&o, 0, sizeof(Router)); }
+	Router(LDKRouter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouter)); }
+	operator LDKRouter() && { LDKRouter res = self; memset(&self, 0, sizeof(LDKRouter)); return res; }
+	~Router() { Router_free(self); }
+	Router& operator=(Router&& o) { Router_free(self); self = o.self; memset(&o, 0, sizeof(Router)); return *this; }
+	LDKRouter* operator &() { return &self; }
+	LDKRouter* operator ->() { return &self; }
+	const LDKRouter* operator &() const { return &self; }
+	const LDKRouter* operator ->() const { return &self; }
+	/**
+	 *  Finds a [`Route`] between `payer` and `payee` for a payment with the given values.
+	 * 
+	 *  Note that first_hops (or a relevant inner pointer) may be NULL or all-0s to represent None
+	 */
+	inline LDK::CResult_RouteLightningErrorZ find_route(struct LDKPublicKey payer, const struct LDKRouteParameters *NONNULL_PTR route_params, const uint8_t (*payment_hash)[32], struct LDKCVec_ChannelDetailsZ *first_hops, const struct LDKScore *NONNULL_PTR scorer);
+};
+class RetryAttempts {
+private:
+	LDKRetryAttempts self;
+public:
+	RetryAttempts(const RetryAttempts&) = delete;
+	RetryAttempts(RetryAttempts&& o) : self(o.self) { memset(&o, 0, sizeof(RetryAttempts)); }
+	RetryAttempts(LDKRetryAttempts&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRetryAttempts)); }
+	operator LDKRetryAttempts() && { LDKRetryAttempts res = self; memset(&self, 0, sizeof(LDKRetryAttempts)); return res; }
+	~RetryAttempts() { RetryAttempts_free(self); }
+	RetryAttempts& operator=(RetryAttempts&& o) { RetryAttempts_free(self); self = o.self; memset(&o, 0, sizeof(RetryAttempts)); return *this; }
+	LDKRetryAttempts* operator &() { return &self; }
+	LDKRetryAttempts* operator ->() { return &self; }
+	const LDKRetryAttempts* operator &() const { return &self; }
+	const LDKRetryAttempts* operator ->() const { return &self; }
+};
+class PaymentError {
+private:
+	LDKPaymentError self;
+public:
+	PaymentError(const PaymentError&) = delete;
+	PaymentError(PaymentError&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentError)); }
+	PaymentError(LDKPaymentError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentError)); }
+	operator LDKPaymentError() && { LDKPaymentError res = self; memset(&self, 0, sizeof(LDKPaymentError)); return res; }
+	~PaymentError() { PaymentError_free(self); }
+	PaymentError& operator=(PaymentError&& o) { PaymentError_free(self); self = o.self; memset(&o, 0, sizeof(PaymentError)); return *this; }
+	LDKPaymentError* operator &() { return &self; }
+	LDKPaymentError* operator ->() { return &self; }
+	const LDKPaymentError* operator &() const { return &self; }
+	const LDKPaymentError* operator ->() const { return &self; }
+};
 class Invoice {
 private:
 	LDKInvoice self;
@@ -2045,21 +2426,6 @@ public:
 	const LDKChannelMonitorUpdate* operator &() const { return &self; }
 	const LDKChannelMonitorUpdate* operator ->() const { return &self; }
 };
-class MonitorUpdateError {
-private:
-	LDKMonitorUpdateError self;
-public:
-	MonitorUpdateError(const MonitorUpdateError&) = delete;
-	MonitorUpdateError(MonitorUpdateError&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorUpdateError)); }
-	MonitorUpdateError(LDKMonitorUpdateError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorUpdateError)); }
-	operator LDKMonitorUpdateError() && { LDKMonitorUpdateError res = self; memset(&self, 0, sizeof(LDKMonitorUpdateError)); return res; }
-	~MonitorUpdateError() { MonitorUpdateError_free(self); }
-	MonitorUpdateError& operator=(MonitorUpdateError&& o) { MonitorUpdateError_free(self); self = o.self; memset(&o, 0, sizeof(MonitorUpdateError)); return *this; }
-	LDKMonitorUpdateError* operator &() { return &self; }
-	LDKMonitorUpdateError* operator ->() { return &self; }
-	const LDKMonitorUpdateError* operator &() const { return &self; }
-	const LDKMonitorUpdateError* operator ->() const { return &self; }
-};
 class MonitorEvent {
 private:
 	LDKMonitorEvent self;
@@ -2346,20 +2712,20 @@ public:
 	const LDKNetGraphMsgHandler* operator &() const { return &self; }
 	const LDKNetGraphMsgHandler* operator ->() const { return &self; }
 };
-class DirectionalChannelInfo {
+class ChannelUpdateInfo {
 private:
-	LDKDirectionalChannelInfo self;
+	LDKChannelUpdateInfo self;
 public:
-	DirectionalChannelInfo(const DirectionalChannelInfo&) = delete;
-	DirectionalChannelInfo(DirectionalChannelInfo&& o) : self(o.self) { memset(&o, 0, sizeof(DirectionalChannelInfo)); }
-	DirectionalChannelInfo(LDKDirectionalChannelInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDirectionalChannelInfo)); }
-	operator LDKDirectionalChannelInfo() && { LDKDirectionalChannelInfo res = self; memset(&self, 0, sizeof(LDKDirectionalChannelInfo)); return res; }
-	~DirectionalChannelInfo() { DirectionalChannelInfo_free(self); }
-	DirectionalChannelInfo& operator=(DirectionalChannelInfo&& o) { DirectionalChannelInfo_free(self); self = o.self; memset(&o, 0, sizeof(DirectionalChannelInfo)); return *this; }
-	LDKDirectionalChannelInfo* operator &() { return &self; }
-	LDKDirectionalChannelInfo* operator ->() { return &self; }
-	const LDKDirectionalChannelInfo* operator &() const { return &self; }
-	const LDKDirectionalChannelInfo* operator ->() const { return &self; }
+	ChannelUpdateInfo(const ChannelUpdateInfo&) = delete;
+	ChannelUpdateInfo(ChannelUpdateInfo&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelUpdateInfo)); }
+	ChannelUpdateInfo(LDKChannelUpdateInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelUpdateInfo)); }
+	operator LDKChannelUpdateInfo() && { LDKChannelUpdateInfo res = self; memset(&self, 0, sizeof(LDKChannelUpdateInfo)); return res; }
+	~ChannelUpdateInfo() { ChannelUpdateInfo_free(self); }
+	ChannelUpdateInfo& operator=(ChannelUpdateInfo&& o) { ChannelUpdateInfo_free(self); self = o.self; memset(&o, 0, sizeof(ChannelUpdateInfo)); return *this; }
+	LDKChannelUpdateInfo* operator &() { return &self; }
+	LDKChannelUpdateInfo* operator ->() { return &self; }
+	const LDKChannelUpdateInfo* operator &() const { return &self; }
+	const LDKChannelUpdateInfo* operator ->() const { return &self; }
 };
 class ChannelInfo {
 private:
@@ -2376,6 +2742,36 @@ public:
 	const LDKChannelInfo* operator &() const { return &self; }
 	const LDKChannelInfo* operator ->() const { return &self; }
 };
+class DirectedChannelInfo {
+private:
+	LDKDirectedChannelInfo self;
+public:
+	DirectedChannelInfo(const DirectedChannelInfo&) = delete;
+	DirectedChannelInfo(DirectedChannelInfo&& o) : self(o.self) { memset(&o, 0, sizeof(DirectedChannelInfo)); }
+	DirectedChannelInfo(LDKDirectedChannelInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDirectedChannelInfo)); }
+	operator LDKDirectedChannelInfo() && { LDKDirectedChannelInfo res = self; memset(&self, 0, sizeof(LDKDirectedChannelInfo)); return res; }
+	~DirectedChannelInfo() { DirectedChannelInfo_free(self); }
+	DirectedChannelInfo& operator=(DirectedChannelInfo&& o) { DirectedChannelInfo_free(self); self = o.self; memset(&o, 0, sizeof(DirectedChannelInfo)); return *this; }
+	LDKDirectedChannelInfo* operator &() { return &self; }
+	LDKDirectedChannelInfo* operator ->() { return &self; }
+	const LDKDirectedChannelInfo* operator &() const { return &self; }
+	const LDKDirectedChannelInfo* operator ->() const { return &self; }
+};
+class EffectiveCapacity {
+private:
+	LDKEffectiveCapacity self;
+public:
+	EffectiveCapacity(const EffectiveCapacity&) = delete;
+	EffectiveCapacity(EffectiveCapacity&& o) : self(o.self) { memset(&o, 0, sizeof(EffectiveCapacity)); }
+	EffectiveCapacity(LDKEffectiveCapacity&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEffectiveCapacity)); }
+	operator LDKEffectiveCapacity() && { LDKEffectiveCapacity res = self; memset(&self, 0, sizeof(LDKEffectiveCapacity)); return res; }
+	~EffectiveCapacity() { EffectiveCapacity_free(self); }
+	EffectiveCapacity& operator=(EffectiveCapacity&& o) { EffectiveCapacity_free(self); self = o.self; memset(&o, 0, sizeof(EffectiveCapacity)); return *this; }
+	LDKEffectiveCapacity* operator &() { return &self; }
+	LDKEffectiveCapacity* operator ->() { return &self; }
+	const LDKEffectiveCapacity* operator &() const { return &self; }
+	const LDKEffectiveCapacity* operator ->() const { return &self; }
+};
 class RoutingFees {
 private:
 	LDKRoutingFees self;
@@ -2466,6 +2862,21 @@ public:
 	const LDKErrorMessage* operator &() const { return &self; }
 	const LDKErrorMessage* operator ->() const { return &self; }
 };
+class WarningMessage {
+private:
+	LDKWarningMessage self;
+public:
+	WarningMessage(const WarningMessage&) = delete;
+	WarningMessage(WarningMessage&& o) : self(o.self) { memset(&o, 0, sizeof(WarningMessage)); }
+	WarningMessage(LDKWarningMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWarningMessage)); }
+	operator LDKWarningMessage() && { LDKWarningMessage res = self; memset(&self, 0, sizeof(LDKWarningMessage)); return res; }
+	~WarningMessage() { WarningMessage_free(self); }
+	WarningMessage& operator=(WarningMessage&& o) { WarningMessage_free(self); self = o.self; memset(&o, 0, sizeof(WarningMessage)); return *this; }
+	LDKWarningMessage* operator &() { return &self; }
+	LDKWarningMessage* operator ->() { return &self; }
+	const LDKWarningMessage* operator &() const { return &self; }
+	const LDKWarningMessage* operator ->() const { return &self; }
+};
 class Ping {
 private:
 	LDKPing self;
@@ -3163,6 +3574,21 @@ public:
 	 */
 	inline LDK::CResult_NoneLightningErrorZ handle_query_short_channel_ids(struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg);
 };
+class DefaultRouter {
+private:
+	LDKDefaultRouter self;
+public:
+	DefaultRouter(const DefaultRouter&) = delete;
+	DefaultRouter(DefaultRouter&& o) : self(o.self) { memset(&o, 0, sizeof(DefaultRouter)); }
+	DefaultRouter(LDKDefaultRouter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDefaultRouter)); }
+	operator LDKDefaultRouter() && { LDKDefaultRouter res = self; memset(&self, 0, sizeof(LDKDefaultRouter)); return res; }
+	~DefaultRouter() { DefaultRouter_free(self); }
+	DefaultRouter& operator=(DefaultRouter&& o) { DefaultRouter_free(self); self = o.self; memset(&o, 0, sizeof(DefaultRouter)); return *this; }
+	LDKDefaultRouter* operator &() { return &self; }
+	LDKDefaultRouter* operator ->() { return &self; }
+	const LDKDefaultRouter* operator &() const { return &self; }
+	const LDKDefaultRouter* operator ->() const { return &self; }
+};
 class Level {
 private:
 	LDKLevel self;
@@ -3177,6 +3603,21 @@ public:
 	const LDKLevel* operator &() const { return &self; }
 	const LDKLevel* operator ->() const { return &self; }
 };
+class Record {
+private:
+	LDKRecord self;
+public:
+	Record(const Record&) = delete;
+	Record(Record&& o) : self(o.self) { memset(&o, 0, sizeof(Record)); }
+	Record(LDKRecord&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRecord)); }
+	operator LDKRecord() && { LDKRecord res = self; memset(&self, 0, sizeof(LDKRecord)); return res; }
+	~Record() { Record_free(self); }
+	Record& operator=(Record&& o) { Record_free(self); self = o.self; memset(&o, 0, sizeof(Record)); return *this; }
+	LDKRecord* operator &() { return &self; }
+	LDKRecord* operator ->() { return &self; }
+	const LDKRecord* operator &() const { return &self; }
+	const LDKRecord* operator ->() const { return &self; }
+};
 class Logger {
 private:
 	LDKLogger self;
@@ -3194,7 +3635,22 @@ public:
 	/**
 	 *  Logs the `Record`
 	 */
-	inline void log(const char *record);
+	inline void log(const struct LDKRecord *NONNULL_PTR record);
+};
+class MonitorUpdateId {
+private:
+	LDKMonitorUpdateId self;
+public:
+	MonitorUpdateId(const MonitorUpdateId&) = delete;
+	MonitorUpdateId(MonitorUpdateId&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorUpdateId)); }
+	MonitorUpdateId(LDKMonitorUpdateId&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorUpdateId)); }
+	operator LDKMonitorUpdateId() && { LDKMonitorUpdateId res = self; memset(&self, 0, sizeof(LDKMonitorUpdateId)); return res; }
+	~MonitorUpdateId() { MonitorUpdateId_free(self); }
+	MonitorUpdateId& operator=(MonitorUpdateId&& o) { MonitorUpdateId_free(self); self = o.self; memset(&o, 0, sizeof(MonitorUpdateId)); return *this; }
+	LDKMonitorUpdateId* operator &() { return &self; }
+	LDKMonitorUpdateId* operator ->() { return &self; }
+	const LDKMonitorUpdateId* operator &() const { return &self; }
+	const LDKMonitorUpdateId* operator ->() const { return &self; }
 };
 class Persist {
 private:
@@ -3211,25 +3667,36 @@ public:
 	const LDKPersist* operator &() const { return &self; }
 	const LDKPersist* operator ->() const { return &self; }
 	/**
-	 *  Persist a new channel's data. The data can be stored any way you want, but
-	 *  the identifier provided by Rust-Lightning is the channel's outpoint (and
-	 *  it is up to you to maintain a correct mapping between the outpoint and the
-	 *  stored channel data). Note that you **must** persist every new monitor to
-	 *  disk. See the `Persist` trait documentation for more details.
+	 *  Persist a new channel's data in response to a [`chain::Watch::watch_channel`] call. This is
+	 *  called by [`ChannelManager`] for new channels, or may be called directly, e.g. on startup.
+	 * 
+	 *  The data can be stored any way you want, but the identifier provided by LDK is the
+	 *  channel's outpoint (and it is up to you to maintain a correct mapping between the outpoint
+	 *  and the stored channel data). Note that you **must** persist every new monitor to disk.
+	 * 
+	 *  The `update_id` is used to identify this call to [`ChainMonitor::channel_monitor_updated`],
+	 *  if you return [`ChannelMonitorUpdateErr::TemporaryFailure`].
 	 * 
 	 *  See [`Writeable::write`] on [`ChannelMonitor`] for writing out a `ChannelMonitor`
 	 *  and [`ChannelMonitorUpdateErr`] for requirements when returning errors.
 	 * 
+	 *  [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
 	 *  [`Writeable::write`]: crate::util::ser::Writeable::write
 	 */
-	inline LDK::CResult_NoneChannelMonitorUpdateErrZ persist_new_channel(struct LDKOutPoint id, const struct LDKChannelMonitor *NONNULL_PTR data);
+	inline LDK::CResult_NoneChannelMonitorUpdateErrZ persist_new_channel(struct LDKOutPoint channel_id, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id);
 	/**
-	 *  Update one channel's data. The provided `ChannelMonitor` has already
-	 *  applied the given update.
+	 *  Update one channel's data. The provided [`ChannelMonitor`] has already applied the given
+	 *  update.
 	 * 
-	 *  Note that on every update, you **must** persist either the
-	 *  `ChannelMonitorUpdate` or the updated monitor itself to disk/backups. See
-	 *  the `Persist` trait documentation for more details.
+	 *  Note that on every update, you **must** persist either the [`ChannelMonitorUpdate`] or the
+	 *  updated monitor itself to disk/backups. See the [`Persist`] trait documentation for more
+	 *  details.
+	 * 
+	 *  During blockchain synchronization operations, this may be called with no
+	 *  [`ChannelMonitorUpdate`], in which case the full [`ChannelMonitor`] needs to be persisted.
+	 *  Note that after the full [`ChannelMonitor`] is persisted any previous
+	 *  [`ChannelMonitorUpdate`]s which were persisted should be discarded - they can no longer be
+	 *  applied to the persisted [`ChannelMonitor`] as they were already applied.
 	 * 
 	 *  If an implementer chooses to persist the updates only, they need to make
 	 *  sure that all the updates are applied to the `ChannelMonitors` *before*
@@ -3243,13 +3710,18 @@ public:
 	 *  them in batches. The size of each monitor grows `O(number of state updates)`
 	 *  whereas updates are small and `O(1)`.
 	 * 
+	 *  The `update_id` is used to identify this call to [`ChainMonitor::channel_monitor_updated`],
+	 *  if you return [`ChannelMonitorUpdateErr::TemporaryFailure`].
+	 * 
 	 *  See [`Writeable::write`] on [`ChannelMonitor`] for writing out a `ChannelMonitor`,
 	 *  [`Writeable::write`] on [`ChannelMonitorUpdate`] for writing out an update, and
 	 *  [`ChannelMonitorUpdateErr`] for requirements when returning errors.
 	 * 
 	 *  [`Writeable::write`]: crate::util::ser::Writeable::write
+	 * 
+	 *  Note that update (or a relevant inner pointer) may be NULL or all-0s to represent None
 	 */
-	inline LDK::CResult_NoneChannelMonitorUpdateErrZ update_persisted_channel(struct LDKOutPoint id, const struct LDKChannelMonitorUpdate *NONNULL_PTR update, const struct LDKChannelMonitor *NONNULL_PTR data);
+	inline LDK::CResult_NoneChannelMonitorUpdateErrZ update_persisted_channel(struct LDKOutPoint channel_id, const struct LDKChannelMonitorUpdate *NONNULL_PTR update, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id);
 };
 class LockedChannelMonitor {
 private:
@@ -3311,6 +3783,21 @@ public:
 	const LDKCResult_LockedChannelMonitorNoneZ* operator &() const { return &self; }
 	const LDKCResult_LockedChannelMonitorNoneZ* operator ->() const { return &self; }
 };
+class CResult_PhantomRouteHintsDecodeErrorZ {
+private:
+	LDKCResult_PhantomRouteHintsDecodeErrorZ self;
+public:
+	CResult_PhantomRouteHintsDecodeErrorZ(const CResult_PhantomRouteHintsDecodeErrorZ&) = delete;
+	CResult_PhantomRouteHintsDecodeErrorZ(CResult_PhantomRouteHintsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PhantomRouteHintsDecodeErrorZ)); }
+	CResult_PhantomRouteHintsDecodeErrorZ(LDKCResult_PhantomRouteHintsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ)); }
+	operator LDKCResult_PhantomRouteHintsDecodeErrorZ() && { LDKCResult_PhantomRouteHintsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ)); return res; }
+	~CResult_PhantomRouteHintsDecodeErrorZ() { CResult_PhantomRouteHintsDecodeErrorZ_free(self); }
+	CResult_PhantomRouteHintsDecodeErrorZ& operator=(CResult_PhantomRouteHintsDecodeErrorZ&& o) { CResult_PhantomRouteHintsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PhantomRouteHintsDecodeErrorZ)); return *this; }
+	LDKCResult_PhantomRouteHintsDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_PhantomRouteHintsDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_PhantomRouteHintsDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_PhantomRouteHintsDecodeErrorZ* operator ->() const { return &self; }
+};
 class CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ {
 private:
 	LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ self;
@@ -3326,20 +3813,20 @@ public:
 	const LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* operator &() const { return &self; }
 	const LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* operator ->() const { return &self; }
 };
-class CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ {
+class CResult_ScoringParametersDecodeErrorZ {
 private:
-	LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ self;
+	LDKCResult_ScoringParametersDecodeErrorZ self;
 public:
-	CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ(const CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ&) = delete;
-	CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ(CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ)); }
-	CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ(LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ)); }
-	operator LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ() && { LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ)); return res; }
-	~CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ() { CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(self); }
-	CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ& operator=(CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ&& o) { CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ)); return *this; }
-	LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ* operator &() { return &self; }
-	LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ* operator ->() { return &self; }
-	const LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ* operator &() const { return &self; }
-	const LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ* operator ->() const { return &self; }
+	CResult_ScoringParametersDecodeErrorZ(const CResult_ScoringParametersDecodeErrorZ&) = delete;
+	CResult_ScoringParametersDecodeErrorZ(CResult_ScoringParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ScoringParametersDecodeErrorZ)); }
+	CResult_ScoringParametersDecodeErrorZ(LDKCResult_ScoringParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ScoringParametersDecodeErrorZ)); }
+	operator LDKCResult_ScoringParametersDecodeErrorZ() && { LDKCResult_ScoringParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ScoringParametersDecodeErrorZ)); return res; }
+	~CResult_ScoringParametersDecodeErrorZ() { CResult_ScoringParametersDecodeErrorZ_free(self); }
+	CResult_ScoringParametersDecodeErrorZ& operator=(CResult_ScoringParametersDecodeErrorZ&& o) { CResult_ScoringParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ScoringParametersDecodeErrorZ)); return *this; }
+	LDKCResult_ScoringParametersDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_ScoringParametersDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_ScoringParametersDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_ScoringParametersDecodeErrorZ* operator ->() const { return &self; }
 };
 class CResult_HTLCUpdateDecodeErrorZ {
 private:
@@ -3371,6 +3858,21 @@ public:
 	const LDKC2Tuple_SignatureCVec_SignatureZZ* operator &() const { return &self; }
 	const LDKC2Tuple_SignatureCVec_SignatureZZ* operator ->() const { return &self; }
 };
+class CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ {
+private:
+	LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ self;
+public:
+	CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ(const CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ&) = delete;
+	CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ(CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ)); }
+	CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ(LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ)); }
+	operator LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ() && { LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ)); return res; }
+	~CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ() { CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(self); }
+	CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ& operator=(CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ&& o) { CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ)); return *this; }
+	LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ* operator &() { return &self; }
+	LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ* operator ->() { return &self; }
+	const LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ* operator &() const { return &self; }
+	const LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ* operator ->() const { return &self; }
+};
 class CVec_C2Tuple_u32TxOutZZ {
 private:
 	LDKCVec_C2Tuple_u32TxOutZZ self;
@@ -3551,6 +4053,21 @@ public:
 	const LDKCResult_TrustedClosingTransactionNoneZ* operator &() const { return &self; }
 	const LDKCResult_TrustedClosingTransactionNoneZ* operator ->() const { return &self; }
 };
+class CResult_PaymentPreimageAPIErrorZ {
+private:
+	LDKCResult_PaymentPreimageAPIErrorZ self;
+public:
+	CResult_PaymentPreimageAPIErrorZ(const CResult_PaymentPreimageAPIErrorZ&) = delete;
+	CResult_PaymentPreimageAPIErrorZ(CResult_PaymentPreimageAPIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentPreimageAPIErrorZ)); }
+	CResult_PaymentPreimageAPIErrorZ(LDKCResult_PaymentPreimageAPIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentPreimageAPIErrorZ)); }
+	operator LDKCResult_PaymentPreimageAPIErrorZ() && { LDKCResult_PaymentPreimageAPIErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentPreimageAPIErrorZ)); return res; }
+	~CResult_PaymentPreimageAPIErrorZ() { CResult_PaymentPreimageAPIErrorZ_free(self); }
+	CResult_PaymentPreimageAPIErrorZ& operator=(CResult_PaymentPreimageAPIErrorZ&& o) { CResult_PaymentPreimageAPIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentPreimageAPIErrorZ)); return *this; }
+	LDKCResult_PaymentPreimageAPIErrorZ* operator &() { return &self; }
+	LDKCResult_PaymentPreimageAPIErrorZ* operator ->() { return &self; }
+	const LDKCResult_PaymentPreimageAPIErrorZ* operator &() const { return &self; }
+	const LDKCResult_PaymentPreimageAPIErrorZ* operator ->() const { return &self; }
+};
 class CResult_ChannelMonitorUpdateDecodeErrorZ {
 private:
 	LDKCResult_ChannelMonitorUpdateDecodeErrorZ self;
@@ -3566,6 +4083,21 @@ public:
 	const LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator ->() const { return &self; }
 };
+class CResult_RouteHintDecodeErrorZ {
+private:
+	LDKCResult_RouteHintDecodeErrorZ self;
+public:
+	CResult_RouteHintDecodeErrorZ(const CResult_RouteHintDecodeErrorZ&) = delete;
+	CResult_RouteHintDecodeErrorZ(CResult_RouteHintDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteHintDecodeErrorZ)); }
+	CResult_RouteHintDecodeErrorZ(LDKCResult_RouteHintDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteHintDecodeErrorZ)); }
+	operator LDKCResult_RouteHintDecodeErrorZ() && { LDKCResult_RouteHintDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteHintDecodeErrorZ)); return res; }
+	~CResult_RouteHintDecodeErrorZ() { CResult_RouteHintDecodeErrorZ_free(self); }
+	CResult_RouteHintDecodeErrorZ& operator=(CResult_RouteHintDecodeErrorZ&& o) { CResult_RouteHintDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteHintDecodeErrorZ)); return *this; }
+	LDKCResult_RouteHintDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_RouteHintDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_RouteHintDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_RouteHintDecodeErrorZ* operator ->() const { return &self; }
+};
 class C2Tuple_PublicKeyTypeZ {
 private:
 	LDKC2Tuple_PublicKeyTypeZ self;
@@ -3611,36 +4143,6 @@ public:
 	const LDKCResult_ChannelReestablishDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_ChannelReestablishDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_UnsignedNodeAnnouncementDecodeErrorZ {
-private:
-	LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ self;
-public:
-	CResult_UnsignedNodeAnnouncementDecodeErrorZ(const CResult_UnsignedNodeAnnouncementDecodeErrorZ&) = delete;
-	CResult_UnsignedNodeAnnouncementDecodeErrorZ(CResult_UnsignedNodeAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnsignedNodeAnnouncementDecodeErrorZ)); }
-	CResult_UnsignedNodeAnnouncementDecodeErrorZ(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ)); }
-	operator LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ() && { LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ)); return res; }
-	~CResult_UnsignedNodeAnnouncementDecodeErrorZ() { CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(self); }
-	CResult_UnsignedNodeAnnouncementDecodeErrorZ& operator=(CResult_UnsignedNodeAnnouncementDecodeErrorZ&& o) { CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnsignedNodeAnnouncementDecodeErrorZ)); return *this; }
-	LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_ReplyChannelRangeDecodeErrorZ {
-private:
-	LDKCResult_ReplyChannelRangeDecodeErrorZ self;
-public:
-	CResult_ReplyChannelRangeDecodeErrorZ(const CResult_ReplyChannelRangeDecodeErrorZ&) = delete;
-	CResult_ReplyChannelRangeDecodeErrorZ(CResult_ReplyChannelRangeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ReplyChannelRangeDecodeErrorZ)); }
-	CResult_ReplyChannelRangeDecodeErrorZ(LDKCResult_ReplyChannelRangeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ)); }
-	operator LDKCResult_ReplyChannelRangeDecodeErrorZ() && { LDKCResult_ReplyChannelRangeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ)); return res; }
-	~CResult_ReplyChannelRangeDecodeErrorZ() { CResult_ReplyChannelRangeDecodeErrorZ_free(self); }
-	CResult_ReplyChannelRangeDecodeErrorZ& operator=(CResult_ReplyChannelRangeDecodeErrorZ&& o) { CResult_ReplyChannelRangeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ReplyChannelRangeDecodeErrorZ)); return *this; }
-	LDKCResult_ReplyChannelRangeDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_ReplyChannelRangeDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_ReplyChannelRangeDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_ReplyChannelRangeDecodeErrorZ* operator ->() const { return &self; }
-};
 class CResult_CommitmentSignedDecodeErrorZ {
 private:
 	LDKCResult_CommitmentSignedDecodeErrorZ self;
@@ -3671,20 +4173,20 @@ public:
 	const LDKCVec_UpdateAddHTLCZ* operator &() const { return &self; }
 	const LDKCVec_UpdateAddHTLCZ* operator ->() const { return &self; }
 };
-class CResult_GossipTimestampFilterDecodeErrorZ {
+class CResult_UnsignedNodeAnnouncementDecodeErrorZ {
 private:
-	LDKCResult_GossipTimestampFilterDecodeErrorZ self;
+	LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ self;
 public:
-	CResult_GossipTimestampFilterDecodeErrorZ(const CResult_GossipTimestampFilterDecodeErrorZ&) = delete;
-	CResult_GossipTimestampFilterDecodeErrorZ(CResult_GossipTimestampFilterDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_GossipTimestampFilterDecodeErrorZ)); }
-	CResult_GossipTimestampFilterDecodeErrorZ(LDKCResult_GossipTimestampFilterDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ)); }
-	operator LDKCResult_GossipTimestampFilterDecodeErrorZ() && { LDKCResult_GossipTimestampFilterDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ)); return res; }
-	~CResult_GossipTimestampFilterDecodeErrorZ() { CResult_GossipTimestampFilterDecodeErrorZ_free(self); }
-	CResult_GossipTimestampFilterDecodeErrorZ& operator=(CResult_GossipTimestampFilterDecodeErrorZ&& o) { CResult_GossipTimestampFilterDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_GossipTimestampFilterDecodeErrorZ)); return *this; }
-	LDKCResult_GossipTimestampFilterDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_GossipTimestampFilterDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_GossipTimestampFilterDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_GossipTimestampFilterDecodeErrorZ* operator ->() const { return &self; }
+	CResult_UnsignedNodeAnnouncementDecodeErrorZ(const CResult_UnsignedNodeAnnouncementDecodeErrorZ&) = delete;
+	CResult_UnsignedNodeAnnouncementDecodeErrorZ(CResult_UnsignedNodeAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnsignedNodeAnnouncementDecodeErrorZ)); }
+	CResult_UnsignedNodeAnnouncementDecodeErrorZ(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ)); }
+	operator LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ() && { LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ)); return res; }
+	~CResult_UnsignedNodeAnnouncementDecodeErrorZ() { CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(self); }
+	CResult_UnsignedNodeAnnouncementDecodeErrorZ& operator=(CResult_UnsignedNodeAnnouncementDecodeErrorZ&& o) { CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnsignedNodeAnnouncementDecodeErrorZ)); return *this; }
+	LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator ->() const { return &self; }
 };
 class COption_u32Z {
 private:
@@ -3746,23 +4248,23 @@ public:
 	const LDKCResult_PaymentIdPaymentSendFailureZ* operator &() const { return &self; }
 	const LDKCResult_PaymentIdPaymentSendFailureZ* operator ->() const { return &self; }
 };
-class CResult_InvoiceSignOrCreationErrorZ {
+class CResult_ReplyChannelRangeDecodeErrorZ {
 private:
-	LDKCResult_InvoiceSignOrCreationErrorZ self;
+	LDKCResult_ReplyChannelRangeDecodeErrorZ self;
 public:
-	CResult_InvoiceSignOrCreationErrorZ(const CResult_InvoiceSignOrCreationErrorZ&) = delete;
-	CResult_InvoiceSignOrCreationErrorZ(CResult_InvoiceSignOrCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceSignOrCreationErrorZ)); }
-	CResult_InvoiceSignOrCreationErrorZ(LDKCResult_InvoiceSignOrCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceSignOrCreationErrorZ)); }
-	operator LDKCResult_InvoiceSignOrCreationErrorZ() && { LDKCResult_InvoiceSignOrCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceSignOrCreationErrorZ)); return res; }
-	~CResult_InvoiceSignOrCreationErrorZ() { CResult_InvoiceSignOrCreationErrorZ_free(self); }
-	CResult_InvoiceSignOrCreationErrorZ& operator=(CResult_InvoiceSignOrCreationErrorZ&& o) { CResult_InvoiceSignOrCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceSignOrCreationErrorZ)); return *this; }
-	LDKCResult_InvoiceSignOrCreationErrorZ* operator &() { return &self; }
-	LDKCResult_InvoiceSignOrCreationErrorZ* operator ->() { return &self; }
-	const LDKCResult_InvoiceSignOrCreationErrorZ* operator &() const { return &self; }
-	const LDKCResult_InvoiceSignOrCreationErrorZ* operator ->() const { return &self; }
-};
-class CResult_CommitmentTransactionDecodeErrorZ {
-private:
+	CResult_ReplyChannelRangeDecodeErrorZ(const CResult_ReplyChannelRangeDecodeErrorZ&) = delete;
+	CResult_ReplyChannelRangeDecodeErrorZ(CResult_ReplyChannelRangeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ReplyChannelRangeDecodeErrorZ)); }
+	CResult_ReplyChannelRangeDecodeErrorZ(LDKCResult_ReplyChannelRangeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ)); }
+	operator LDKCResult_ReplyChannelRangeDecodeErrorZ() && { LDKCResult_ReplyChannelRangeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ)); return res; }
+	~CResult_ReplyChannelRangeDecodeErrorZ() { CResult_ReplyChannelRangeDecodeErrorZ_free(self); }
+	CResult_ReplyChannelRangeDecodeErrorZ& operator=(CResult_ReplyChannelRangeDecodeErrorZ&& o) { CResult_ReplyChannelRangeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ReplyChannelRangeDecodeErrorZ)); return *this; }
+	LDKCResult_ReplyChannelRangeDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_ReplyChannelRangeDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_ReplyChannelRangeDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_ReplyChannelRangeDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_CommitmentTransactionDecodeErrorZ {
+private:
 	LDKCResult_CommitmentTransactionDecodeErrorZ self;
 public:
 	CResult_CommitmentTransactionDecodeErrorZ(const CResult_CommitmentTransactionDecodeErrorZ&) = delete;
@@ -3821,21 +4323,6 @@ public:
 	const LDKCResult_SignedRawInvoiceNoneZ* operator &() const { return &self; }
 	const LDKCResult_SignedRawInvoiceNoneZ* operator ->() const { return &self; }
 };
-class CResult_ExpiryTimeCreationErrorZ {
-private:
-	LDKCResult_ExpiryTimeCreationErrorZ self;
-public:
-	CResult_ExpiryTimeCreationErrorZ(const CResult_ExpiryTimeCreationErrorZ&) = delete;
-	CResult_ExpiryTimeCreationErrorZ(CResult_ExpiryTimeCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ExpiryTimeCreationErrorZ)); }
-	CResult_ExpiryTimeCreationErrorZ(LDKCResult_ExpiryTimeCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ExpiryTimeCreationErrorZ)); }
-	operator LDKCResult_ExpiryTimeCreationErrorZ() && { LDKCResult_ExpiryTimeCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ExpiryTimeCreationErrorZ)); return res; }
-	~CResult_ExpiryTimeCreationErrorZ() { CResult_ExpiryTimeCreationErrorZ_free(self); }
-	CResult_ExpiryTimeCreationErrorZ& operator=(CResult_ExpiryTimeCreationErrorZ&& o) { CResult_ExpiryTimeCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ExpiryTimeCreationErrorZ)); return *this; }
-	LDKCResult_ExpiryTimeCreationErrorZ* operator &() { return &self; }
-	LDKCResult_ExpiryTimeCreationErrorZ* operator ->() { return &self; }
-	const LDKCResult_ExpiryTimeCreationErrorZ* operator &() const { return &self; }
-	const LDKCResult_ExpiryTimeCreationErrorZ* operator ->() const { return &self; }
-};
 class CResult_ClosingSignedFeeRangeDecodeErrorZ {
 private:
 	LDKCResult_ClosingSignedFeeRangeDecodeErrorZ self;
@@ -3866,20 +4353,35 @@ public:
 	const LDKCResult_PingDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_PingDecodeErrorZ* operator ->() const { return &self; }
 };
-class COption_FilterZ {
+class CResult_GossipTimestampFilterDecodeErrorZ {
 private:
-	LDKCOption_FilterZ self;
+	LDKCResult_GossipTimestampFilterDecodeErrorZ self;
 public:
-	COption_FilterZ(const COption_FilterZ&) = delete;
-	COption_FilterZ(COption_FilterZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_FilterZ)); }
-	COption_FilterZ(LDKCOption_FilterZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_FilterZ)); }
-	operator LDKCOption_FilterZ() && { LDKCOption_FilterZ res = self; memset(&self, 0, sizeof(LDKCOption_FilterZ)); return res; }
-	~COption_FilterZ() { COption_FilterZ_free(self); }
-	COption_FilterZ& operator=(COption_FilterZ&& o) { COption_FilterZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_FilterZ)); return *this; }
-	LDKCOption_FilterZ* operator &() { return &self; }
-	LDKCOption_FilterZ* operator ->() { return &self; }
-	const LDKCOption_FilterZ* operator &() const { return &self; }
-	const LDKCOption_FilterZ* operator ->() const { return &self; }
+	CResult_GossipTimestampFilterDecodeErrorZ(const CResult_GossipTimestampFilterDecodeErrorZ&) = delete;
+	CResult_GossipTimestampFilterDecodeErrorZ(CResult_GossipTimestampFilterDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_GossipTimestampFilterDecodeErrorZ)); }
+	CResult_GossipTimestampFilterDecodeErrorZ(LDKCResult_GossipTimestampFilterDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ)); }
+	operator LDKCResult_GossipTimestampFilterDecodeErrorZ() && { LDKCResult_GossipTimestampFilterDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ)); return res; }
+	~CResult_GossipTimestampFilterDecodeErrorZ() { CResult_GossipTimestampFilterDecodeErrorZ_free(self); }
+	CResult_GossipTimestampFilterDecodeErrorZ& operator=(CResult_GossipTimestampFilterDecodeErrorZ&& o) { CResult_GossipTimestampFilterDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_GossipTimestampFilterDecodeErrorZ)); return *this; }
+	LDKCResult_GossipTimestampFilterDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_GossipTimestampFilterDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_GossipTimestampFilterDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_GossipTimestampFilterDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_InvoiceSignOrCreationErrorZ {
+private:
+	LDKCResult_InvoiceSignOrCreationErrorZ self;
+public:
+	CResult_InvoiceSignOrCreationErrorZ(const CResult_InvoiceSignOrCreationErrorZ&) = delete;
+	CResult_InvoiceSignOrCreationErrorZ(CResult_InvoiceSignOrCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceSignOrCreationErrorZ)); }
+	CResult_InvoiceSignOrCreationErrorZ(LDKCResult_InvoiceSignOrCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceSignOrCreationErrorZ)); }
+	operator LDKCResult_InvoiceSignOrCreationErrorZ() && { LDKCResult_InvoiceSignOrCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceSignOrCreationErrorZ)); return res; }
+	~CResult_InvoiceSignOrCreationErrorZ() { CResult_InvoiceSignOrCreationErrorZ_free(self); }
+	CResult_InvoiceSignOrCreationErrorZ& operator=(CResult_InvoiceSignOrCreationErrorZ&& o) { CResult_InvoiceSignOrCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceSignOrCreationErrorZ)); return *this; }
+	LDKCResult_InvoiceSignOrCreationErrorZ* operator &() { return &self; }
+	LDKCResult_InvoiceSignOrCreationErrorZ* operator ->() { return &self; }
+	const LDKCResult_InvoiceSignOrCreationErrorZ* operator &() const { return &self; }
+	const LDKCResult_InvoiceSignOrCreationErrorZ* operator ->() const { return &self; }
 };
 class CVec_TransactionOutputsZ {
 private:
@@ -3941,6 +4443,21 @@ public:
 	const LDKCVec_CVec_u8ZZ* operator &() const { return &self; }
 	const LDKCVec_CVec_u8ZZ* operator ->() const { return &self; }
 };
+class COption_FilterZ {
+private:
+	LDKCOption_FilterZ self;
+public:
+	COption_FilterZ(const COption_FilterZ&) = delete;
+	COption_FilterZ(COption_FilterZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_FilterZ)); }
+	COption_FilterZ(LDKCOption_FilterZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_FilterZ)); }
+	operator LDKCOption_FilterZ() && { LDKCOption_FilterZ res = self; memset(&self, 0, sizeof(LDKCOption_FilterZ)); return res; }
+	~COption_FilterZ() { COption_FilterZ_free(self); }
+	COption_FilterZ& operator=(COption_FilterZ&& o) { COption_FilterZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_FilterZ)); return *this; }
+	LDKCOption_FilterZ* operator &() { return &self; }
+	LDKCOption_FilterZ* operator ->() { return &self; }
+	const LDKCOption_FilterZ* operator &() const { return &self; }
+	const LDKCOption_FilterZ* operator ->() const { return &self; }
+};
 class CResult_SecretKeyErrorZ {
 private:
 	LDKCResult_SecretKeyErrorZ self;
@@ -4241,6 +4758,21 @@ public:
 	const LDKCResult_RecoverableSignatureNoneZ* operator &() const { return &self; }
 	const LDKCResult_RecoverableSignatureNoneZ* operator ->() const { return &self; }
 };
+class CResult_COption_NetworkUpdateZDecodeErrorZ {
+private:
+	LDKCResult_COption_NetworkUpdateZDecodeErrorZ self;
+public:
+	CResult_COption_NetworkUpdateZDecodeErrorZ(const CResult_COption_NetworkUpdateZDecodeErrorZ&) = delete;
+	CResult_COption_NetworkUpdateZDecodeErrorZ(CResult_COption_NetworkUpdateZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_NetworkUpdateZDecodeErrorZ)); }
+	CResult_COption_NetworkUpdateZDecodeErrorZ(LDKCResult_COption_NetworkUpdateZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ)); }
+	operator LDKCResult_COption_NetworkUpdateZDecodeErrorZ() && { LDKCResult_COption_NetworkUpdateZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ)); return res; }
+	~CResult_COption_NetworkUpdateZDecodeErrorZ() { CResult_COption_NetworkUpdateZDecodeErrorZ_free(self); }
+	CResult_COption_NetworkUpdateZDecodeErrorZ& operator=(CResult_COption_NetworkUpdateZDecodeErrorZ&& o) { CResult_COption_NetworkUpdateZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_NetworkUpdateZDecodeErrorZ)); return *this; }
+	LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator ->() const { return &self; }
+};
 class CResult_NodeAnnouncementInfoDecodeErrorZ {
 private:
 	LDKCResult_NodeAnnouncementInfoDecodeErrorZ self;
@@ -4256,21 +4788,6 @@ public:
 	const LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_NetAddressu8Z {
-private:
-	LDKCResult_NetAddressu8Z self;
-public:
-	CResult_NetAddressu8Z(const CResult_NetAddressu8Z&) = delete;
-	CResult_NetAddressu8Z(CResult_NetAddressu8Z&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NetAddressu8Z)); }
-	CResult_NetAddressu8Z(LDKCResult_NetAddressu8Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NetAddressu8Z)); }
-	operator LDKCResult_NetAddressu8Z() && { LDKCResult_NetAddressu8Z res = self; memset(&self, 0, sizeof(LDKCResult_NetAddressu8Z)); return res; }
-	~CResult_NetAddressu8Z() { CResult_NetAddressu8Z_free(self); }
-	CResult_NetAddressu8Z& operator=(CResult_NetAddressu8Z&& o) { CResult_NetAddressu8Z_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NetAddressu8Z)); return *this; }
-	LDKCResult_NetAddressu8Z* operator &() { return &self; }
-	LDKCResult_NetAddressu8Z* operator ->() { return &self; }
-	const LDKCResult_NetAddressu8Z* operator &() const { return &self; }
-	const LDKCResult_NetAddressu8Z* operator ->() const { return &self; }
-};
 class C3Tuple_RawInvoice_u832InvoiceSignatureZ {
 private:
 	LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ self;
@@ -4481,6 +4998,51 @@ public:
 	const LDKCVec_CResult_NoneAPIErrorZZ* operator &() const { return &self; }
 	const LDKCVec_CResult_NoneAPIErrorZZ* operator ->() const { return &self; }
 };
+class CResult_CounterpartyCommitmentSecretsDecodeErrorZ {
+private:
+	LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ self;
+public:
+	CResult_CounterpartyCommitmentSecretsDecodeErrorZ(const CResult_CounterpartyCommitmentSecretsDecodeErrorZ&) = delete;
+	CResult_CounterpartyCommitmentSecretsDecodeErrorZ(CResult_CounterpartyCommitmentSecretsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CounterpartyCommitmentSecretsDecodeErrorZ)); }
+	CResult_CounterpartyCommitmentSecretsDecodeErrorZ(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ)); }
+	operator LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ() && { LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ)); return res; }
+	~CResult_CounterpartyCommitmentSecretsDecodeErrorZ() { CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(self); }
+	CResult_CounterpartyCommitmentSecretsDecodeErrorZ& operator=(CResult_CounterpartyCommitmentSecretsDecodeErrorZ&& o) { CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CounterpartyCommitmentSecretsDecodeErrorZ)); return *this; }
+	LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_ChannelCounterpartyDecodeErrorZ {
+private:
+	LDKCResult_ChannelCounterpartyDecodeErrorZ self;
+public:
+	CResult_ChannelCounterpartyDecodeErrorZ(const CResult_ChannelCounterpartyDecodeErrorZ&) = delete;
+	CResult_ChannelCounterpartyDecodeErrorZ(CResult_ChannelCounterpartyDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelCounterpartyDecodeErrorZ)); }
+	CResult_ChannelCounterpartyDecodeErrorZ(LDKCResult_ChannelCounterpartyDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ)); }
+	operator LDKCResult_ChannelCounterpartyDecodeErrorZ() && { LDKCResult_ChannelCounterpartyDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ)); return res; }
+	~CResult_ChannelCounterpartyDecodeErrorZ() { CResult_ChannelCounterpartyDecodeErrorZ_free(self); }
+	CResult_ChannelCounterpartyDecodeErrorZ& operator=(CResult_ChannelCounterpartyDecodeErrorZ&& o) { CResult_ChannelCounterpartyDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelCounterpartyDecodeErrorZ)); return *this; }
+	LDKCResult_ChannelCounterpartyDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_ChannelCounterpartyDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_ChannelCounterpartyDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_ChannelCounterpartyDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_WarningMessageDecodeErrorZ {
+private:
+	LDKCResult_WarningMessageDecodeErrorZ self;
+public:
+	CResult_WarningMessageDecodeErrorZ(const CResult_WarningMessageDecodeErrorZ&) = delete;
+	CResult_WarningMessageDecodeErrorZ(CResult_WarningMessageDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_WarningMessageDecodeErrorZ)); }
+	CResult_WarningMessageDecodeErrorZ(LDKCResult_WarningMessageDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_WarningMessageDecodeErrorZ)); }
+	operator LDKCResult_WarningMessageDecodeErrorZ() && { LDKCResult_WarningMessageDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_WarningMessageDecodeErrorZ)); return res; }
+	~CResult_WarningMessageDecodeErrorZ() { CResult_WarningMessageDecodeErrorZ_free(self); }
+	CResult_WarningMessageDecodeErrorZ& operator=(CResult_WarningMessageDecodeErrorZ&& o) { CResult_WarningMessageDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_WarningMessageDecodeErrorZ)); return *this; }
+	LDKCResult_WarningMessageDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_WarningMessageDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_WarningMessageDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_WarningMessageDecodeErrorZ* operator ->() const { return &self; }
+};
 class CResult_SignatureNoneZ {
 private:
 	LDKCResult_SignatureNoneZ self;
@@ -4496,6 +5058,51 @@ public:
 	const LDKCResult_SignatureNoneZ* operator &() const { return &self; }
 	const LDKCResult_SignatureNoneZ* operator ->() const { return &self; }
 };
+class CVec_RouteHintHopZ {
+private:
+	LDKCVec_RouteHintHopZ self;
+public:
+	CVec_RouteHintHopZ(const CVec_RouteHintHopZ&) = delete;
+	CVec_RouteHintHopZ(CVec_RouteHintHopZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RouteHintHopZ)); }
+	CVec_RouteHintHopZ(LDKCVec_RouteHintHopZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RouteHintHopZ)); }
+	operator LDKCVec_RouteHintHopZ() && { LDKCVec_RouteHintHopZ res = self; memset(&self, 0, sizeof(LDKCVec_RouteHintHopZ)); return res; }
+	~CVec_RouteHintHopZ() { CVec_RouteHintHopZ_free(self); }
+	CVec_RouteHintHopZ& operator=(CVec_RouteHintHopZ&& o) { CVec_RouteHintHopZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_RouteHintHopZ)); return *this; }
+	LDKCVec_RouteHintHopZ* operator &() { return &self; }
+	LDKCVec_RouteHintHopZ* operator ->() { return &self; }
+	const LDKCVec_RouteHintHopZ* operator &() const { return &self; }
+	const LDKCVec_RouteHintHopZ* operator ->() const { return &self; }
+};
+class CResult_SecretKeyNoneZ {
+private:
+	LDKCResult_SecretKeyNoneZ self;
+public:
+	CResult_SecretKeyNoneZ(const CResult_SecretKeyNoneZ&) = delete;
+	CResult_SecretKeyNoneZ(CResult_SecretKeyNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SecretKeyNoneZ)); }
+	CResult_SecretKeyNoneZ(LDKCResult_SecretKeyNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SecretKeyNoneZ)); }
+	operator LDKCResult_SecretKeyNoneZ() && { LDKCResult_SecretKeyNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_SecretKeyNoneZ)); return res; }
+	~CResult_SecretKeyNoneZ() { CResult_SecretKeyNoneZ_free(self); }
+	CResult_SecretKeyNoneZ& operator=(CResult_SecretKeyNoneZ&& o) { CResult_SecretKeyNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SecretKeyNoneZ)); return *this; }
+	LDKCResult_SecretKeyNoneZ* operator &() { return &self; }
+	LDKCResult_SecretKeyNoneZ* operator ->() { return &self; }
+	const LDKCResult_SecretKeyNoneZ* operator &() const { return &self; }
+	const LDKCResult_SecretKeyNoneZ* operator ->() const { return &self; }
+};
+class CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ {
+private:
+	LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ self;
+public:
+	CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ(const CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ&) = delete;
+	CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ(CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ)); }
+	CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ)); }
+	operator LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ() && { LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ)); return res; }
+	~CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ() { CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(self); }
+	CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ& operator=(CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ&& o) { CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ)); return *this; }
+	LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* operator &() { return &self; }
+	LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* operator ->() { return &self; }
+	const LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* operator &() const { return &self; }
+	const LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* operator ->() const { return &self; }
+};
 class C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ {
 private:
 	LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ self;
@@ -4511,6 +5118,21 @@ public:
 	const LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* operator &() const { return &self; }
 	const LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* operator ->() const { return &self; }
 };
+class CResult_PaymentParametersDecodeErrorZ {
+private:
+	LDKCResult_PaymentParametersDecodeErrorZ self;
+public:
+	CResult_PaymentParametersDecodeErrorZ(const CResult_PaymentParametersDecodeErrorZ&) = delete;
+	CResult_PaymentParametersDecodeErrorZ(CResult_PaymentParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentParametersDecodeErrorZ)); }
+	CResult_PaymentParametersDecodeErrorZ(LDKCResult_PaymentParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentParametersDecodeErrorZ)); }
+	operator LDKCResult_PaymentParametersDecodeErrorZ() && { LDKCResult_PaymentParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentParametersDecodeErrorZ)); return res; }
+	~CResult_PaymentParametersDecodeErrorZ() { CResult_PaymentParametersDecodeErrorZ_free(self); }
+	CResult_PaymentParametersDecodeErrorZ& operator=(CResult_PaymentParametersDecodeErrorZ&& o) { CResult_PaymentParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentParametersDecodeErrorZ)); return *this; }
+	LDKCResult_PaymentParametersDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_PaymentParametersDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_PaymentParametersDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_PaymentParametersDecodeErrorZ* operator ->() const { return &self; }
+};
 class CResult_InitDecodeErrorZ {
 private:
 	LDKCResult_InitDecodeErrorZ self;
@@ -4601,35 +5223,35 @@ public:
 	const LDKC2Tuple_OutPointScriptZ* operator &() const { return &self; }
 	const LDKC2Tuple_OutPointScriptZ* operator ->() const { return &self; }
 };
-class CResult_PaymentIdDecodeErrorZ {
+class CResult_RouteHintHopDecodeErrorZ {
 private:
-	LDKCResult_PaymentIdDecodeErrorZ self;
+	LDKCResult_RouteHintHopDecodeErrorZ self;
 public:
-	CResult_PaymentIdDecodeErrorZ(const CResult_PaymentIdDecodeErrorZ&) = delete;
-	CResult_PaymentIdDecodeErrorZ(CResult_PaymentIdDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentIdDecodeErrorZ)); }
-	CResult_PaymentIdDecodeErrorZ(LDKCResult_PaymentIdDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentIdDecodeErrorZ)); }
-	operator LDKCResult_PaymentIdDecodeErrorZ() && { LDKCResult_PaymentIdDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentIdDecodeErrorZ)); return res; }
-	~CResult_PaymentIdDecodeErrorZ() { CResult_PaymentIdDecodeErrorZ_free(self); }
-	CResult_PaymentIdDecodeErrorZ& operator=(CResult_PaymentIdDecodeErrorZ&& o) { CResult_PaymentIdDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentIdDecodeErrorZ)); return *this; }
-	LDKCResult_PaymentIdDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_PaymentIdDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_PaymentIdDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_PaymentIdDecodeErrorZ* operator ->() const { return &self; }
+	CResult_RouteHintHopDecodeErrorZ(const CResult_RouteHintHopDecodeErrorZ&) = delete;
+	CResult_RouteHintHopDecodeErrorZ(CResult_RouteHintHopDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteHintHopDecodeErrorZ)); }
+	CResult_RouteHintHopDecodeErrorZ(LDKCResult_RouteHintHopDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteHintHopDecodeErrorZ)); }
+	operator LDKCResult_RouteHintHopDecodeErrorZ() && { LDKCResult_RouteHintHopDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteHintHopDecodeErrorZ)); return res; }
+	~CResult_RouteHintHopDecodeErrorZ() { CResult_RouteHintHopDecodeErrorZ_free(self); }
+	CResult_RouteHintHopDecodeErrorZ& operator=(CResult_RouteHintHopDecodeErrorZ&& o) { CResult_RouteHintHopDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteHintHopDecodeErrorZ)); return *this; }
+	LDKCResult_RouteHintHopDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_RouteHintHopDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_RouteHintHopDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_RouteHintHopDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_UpdateFailMalformedHTLCDecodeErrorZ {
+class CResult_C2Tuple_SignatureSignatureZNoneZ {
 private:
-	LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ self;
+	LDKCResult_C2Tuple_SignatureSignatureZNoneZ self;
 public:
-	CResult_UpdateFailMalformedHTLCDecodeErrorZ(const CResult_UpdateFailMalformedHTLCDecodeErrorZ&) = delete;
-	CResult_UpdateFailMalformedHTLCDecodeErrorZ(CResult_UpdateFailMalformedHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateFailMalformedHTLCDecodeErrorZ)); }
-	CResult_UpdateFailMalformedHTLCDecodeErrorZ(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ)); }
-	operator LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ() && { LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ)); return res; }
-	~CResult_UpdateFailMalformedHTLCDecodeErrorZ() { CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(self); }
-	CResult_UpdateFailMalformedHTLCDecodeErrorZ& operator=(CResult_UpdateFailMalformedHTLCDecodeErrorZ&& o) { CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateFailMalformedHTLCDecodeErrorZ)); return *this; }
-	LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* operator ->() const { return &self; }
+	CResult_C2Tuple_SignatureSignatureZNoneZ(const CResult_C2Tuple_SignatureSignatureZNoneZ&) = delete;
+	CResult_C2Tuple_SignatureSignatureZNoneZ(CResult_C2Tuple_SignatureSignatureZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_SignatureSignatureZNoneZ)); }
+	CResult_C2Tuple_SignatureSignatureZNoneZ(LDKCResult_C2Tuple_SignatureSignatureZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_SignatureSignatureZNoneZ)); }
+	operator LDKCResult_C2Tuple_SignatureSignatureZNoneZ() && { LDKCResult_C2Tuple_SignatureSignatureZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_SignatureSignatureZNoneZ)); return res; }
+	~CResult_C2Tuple_SignatureSignatureZNoneZ() { CResult_C2Tuple_SignatureSignatureZNoneZ_free(self); }
+	CResult_C2Tuple_SignatureSignatureZNoneZ& operator=(CResult_C2Tuple_SignatureSignatureZNoneZ&& o) { CResult_C2Tuple_SignatureSignatureZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_SignatureSignatureZNoneZ)); return *this; }
+	LDKCResult_C2Tuple_SignatureSignatureZNoneZ* operator &() { return &self; }
+	LDKCResult_C2Tuple_SignatureSignatureZNoneZ* operator ->() { return &self; }
+	const LDKCResult_C2Tuple_SignatureSignatureZNoneZ* operator &() const { return &self; }
+	const LDKCResult_C2Tuple_SignatureSignatureZNoneZ* operator ->() const { return &self; }
 };
 class CVec_NodeAnnouncementZ {
 private:
@@ -4646,6 +5268,21 @@ public:
 	const LDKCVec_NodeAnnouncementZ* operator &() const { return &self; }
 	const LDKCVec_NodeAnnouncementZ* operator ->() const { return &self; }
 };
+class CResult_UpdateFailMalformedHTLCDecodeErrorZ {
+private:
+	LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ self;
+public:
+	CResult_UpdateFailMalformedHTLCDecodeErrorZ(const CResult_UpdateFailMalformedHTLCDecodeErrorZ&) = delete;
+	CResult_UpdateFailMalformedHTLCDecodeErrorZ(CResult_UpdateFailMalformedHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateFailMalformedHTLCDecodeErrorZ)); }
+	CResult_UpdateFailMalformedHTLCDecodeErrorZ(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ)); }
+	operator LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ() && { LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ)); return res; }
+	~CResult_UpdateFailMalformedHTLCDecodeErrorZ() { CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(self); }
+	CResult_UpdateFailMalformedHTLCDecodeErrorZ& operator=(CResult_UpdateFailMalformedHTLCDecodeErrorZ&& o) { CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateFailMalformedHTLCDecodeErrorZ)); return *this; }
+	LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* operator ->() const { return &self; }
+};
 class CResult_UnsignedChannelAnnouncementDecodeErrorZ {
 private:
 	LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ self;
@@ -4676,20 +5313,20 @@ public:
 	const LDKCVec_TxidZ* operator &() const { return &self; }
 	const LDKCVec_TxidZ* operator ->() const { return &self; }
 };
-class CResult_NoneMonitorUpdateErrorZ {
+class COption_AccessZ {
 private:
-	LDKCResult_NoneMonitorUpdateErrorZ self;
+	LDKCOption_AccessZ self;
 public:
-	CResult_NoneMonitorUpdateErrorZ(const CResult_NoneMonitorUpdateErrorZ&) = delete;
-	CResult_NoneMonitorUpdateErrorZ(CResult_NoneMonitorUpdateErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneMonitorUpdateErrorZ)); }
-	CResult_NoneMonitorUpdateErrorZ(LDKCResult_NoneMonitorUpdateErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneMonitorUpdateErrorZ)); }
-	operator LDKCResult_NoneMonitorUpdateErrorZ() && { LDKCResult_NoneMonitorUpdateErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneMonitorUpdateErrorZ)); return res; }
-	~CResult_NoneMonitorUpdateErrorZ() { CResult_NoneMonitorUpdateErrorZ_free(self); }
-	CResult_NoneMonitorUpdateErrorZ& operator=(CResult_NoneMonitorUpdateErrorZ&& o) { CResult_NoneMonitorUpdateErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneMonitorUpdateErrorZ)); return *this; }
-	LDKCResult_NoneMonitorUpdateErrorZ* operator &() { return &self; }
-	LDKCResult_NoneMonitorUpdateErrorZ* operator ->() { return &self; }
-	const LDKCResult_NoneMonitorUpdateErrorZ* operator &() const { return &self; }
-	const LDKCResult_NoneMonitorUpdateErrorZ* operator ->() const { return &self; }
+	COption_AccessZ(const COption_AccessZ&) = delete;
+	COption_AccessZ(COption_AccessZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_AccessZ)); }
+	COption_AccessZ(LDKCOption_AccessZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_AccessZ)); }
+	operator LDKCOption_AccessZ() && { LDKCOption_AccessZ res = self; memset(&self, 0, sizeof(LDKCOption_AccessZ)); return res; }
+	~COption_AccessZ() { COption_AccessZ_free(self); }
+	COption_AccessZ& operator=(COption_AccessZ&& o) { COption_AccessZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_AccessZ)); return *this; }
+	LDKCOption_AccessZ* operator &() { return &self; }
+	LDKCOption_AccessZ* operator ->() { return &self; }
+	const LDKCOption_AccessZ* operator &() const { return &self; }
+	const LDKCOption_AccessZ* operator ->() const { return &self; }
 };
 class CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ {
 private:
@@ -4751,6 +5388,21 @@ public:
 	const LDKCResult_CVec_CVec_u8ZZNoneZ* operator &() const { return &self; }
 	const LDKCResult_CVec_CVec_u8ZZNoneZ* operator ->() const { return &self; }
 };
+class C2Tuple_SignatureSignatureZ {
+private:
+	LDKC2Tuple_SignatureSignatureZ self;
+public:
+	C2Tuple_SignatureSignatureZ(const C2Tuple_SignatureSignatureZ&) = delete;
+	C2Tuple_SignatureSignatureZ(C2Tuple_SignatureSignatureZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_SignatureSignatureZ)); }
+	C2Tuple_SignatureSignatureZ(LDKC2Tuple_SignatureSignatureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_SignatureSignatureZ)); }
+	operator LDKC2Tuple_SignatureSignatureZ() && { LDKC2Tuple_SignatureSignatureZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_SignatureSignatureZ)); return res; }
+	~C2Tuple_SignatureSignatureZ() { C2Tuple_SignatureSignatureZ_free(self); }
+	C2Tuple_SignatureSignatureZ& operator=(C2Tuple_SignatureSignatureZ&& o) { C2Tuple_SignatureSignatureZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_SignatureSignatureZ)); return *this; }
+	LDKC2Tuple_SignatureSignatureZ* operator &() { return &self; }
+	LDKC2Tuple_SignatureSignatureZ* operator ->() { return &self; }
+	const LDKC2Tuple_SignatureSignatureZ* operator &() const { return &self; }
+	const LDKC2Tuple_SignatureSignatureZ* operator ->() const { return &self; }
+};
 class C2Tuple_PaymentHashPaymentSecretZ {
 private:
 	LDKC2Tuple_PaymentHashPaymentSecretZ self;
@@ -4766,21 +5418,6 @@ public:
 	const LDKC2Tuple_PaymentHashPaymentSecretZ* operator &() const { return &self; }
 	const LDKC2Tuple_PaymentHashPaymentSecretZ* operator ->() const { return &self; }
 };
-class COption_AccessZ {
-private:
-	LDKCOption_AccessZ self;
-public:
-	COption_AccessZ(const COption_AccessZ&) = delete;
-	COption_AccessZ(COption_AccessZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_AccessZ)); }
-	COption_AccessZ(LDKCOption_AccessZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_AccessZ)); }
-	operator LDKCOption_AccessZ() && { LDKCOption_AccessZ res = self; memset(&self, 0, sizeof(LDKCOption_AccessZ)); return res; }
-	~COption_AccessZ() { COption_AccessZ_free(self); }
-	COption_AccessZ& operator=(COption_AccessZ&& o) { COption_AccessZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_AccessZ)); return *this; }
-	LDKCOption_AccessZ* operator &() { return &self; }
-	LDKCOption_AccessZ* operator ->() { return &self; }
-	const LDKCOption_AccessZ* operator &() const { return &self; }
-	const LDKCOption_AccessZ* operator ->() const { return &self; }
-};
 class C2Tuple_BlockHashChannelManagerZ {
 private:
 	LDKC2Tuple_BlockHashChannelManagerZ self;
@@ -4856,20 +5493,20 @@ public:
 	const LDKCVec_u64Z* operator &() const { return &self; }
 	const LDKCVec_u64Z* operator ->() const { return &self; }
 };
-class CResult_PongDecodeErrorZ {
+class CResult_ScorerDecodeErrorZ {
 private:
-	LDKCResult_PongDecodeErrorZ self;
+	LDKCResult_ScorerDecodeErrorZ self;
 public:
-	CResult_PongDecodeErrorZ(const CResult_PongDecodeErrorZ&) = delete;
-	CResult_PongDecodeErrorZ(CResult_PongDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PongDecodeErrorZ)); }
-	CResult_PongDecodeErrorZ(LDKCResult_PongDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PongDecodeErrorZ)); }
-	operator LDKCResult_PongDecodeErrorZ() && { LDKCResult_PongDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PongDecodeErrorZ)); return res; }
-	~CResult_PongDecodeErrorZ() { CResult_PongDecodeErrorZ_free(self); }
-	CResult_PongDecodeErrorZ& operator=(CResult_PongDecodeErrorZ&& o) { CResult_PongDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PongDecodeErrorZ)); return *this; }
-	LDKCResult_PongDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_PongDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_PongDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_PongDecodeErrorZ* operator ->() const { return &self; }
+	CResult_ScorerDecodeErrorZ(const CResult_ScorerDecodeErrorZ&) = delete;
+	CResult_ScorerDecodeErrorZ(CResult_ScorerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ScorerDecodeErrorZ)); }
+	CResult_ScorerDecodeErrorZ(LDKCResult_ScorerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ScorerDecodeErrorZ)); }
+	operator LDKCResult_ScorerDecodeErrorZ() && { LDKCResult_ScorerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ScorerDecodeErrorZ)); return res; }
+	~CResult_ScorerDecodeErrorZ() { CResult_ScorerDecodeErrorZ_free(self); }
+	CResult_ScorerDecodeErrorZ& operator=(CResult_ScorerDecodeErrorZ&& o) { CResult_ScorerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ScorerDecodeErrorZ)); return *this; }
+	LDKCResult_ScorerDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_ScorerDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_ScorerDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_ScorerDecodeErrorZ* operator ->() const { return &self; }
 };
 class CResult_DelayedPaymentOutputDescriptorDecodeErrorZ {
 private:
@@ -4901,20 +5538,20 @@ public:
 	const LDKC2Tuple_PaymentHashPaymentIdZ* operator &() const { return &self; }
 	const LDKC2Tuple_PaymentHashPaymentIdZ* operator ->() const { return &self; }
 };
-class CResult_StringErrorZ {
+class CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ {
 private:
-	LDKCResult_StringErrorZ self;
+	LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ self;
 public:
-	CResult_StringErrorZ(const CResult_StringErrorZ&) = delete;
-	CResult_StringErrorZ(CResult_StringErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_StringErrorZ)); }
-	CResult_StringErrorZ(LDKCResult_StringErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_StringErrorZ)); }
-	operator LDKCResult_StringErrorZ() && { LDKCResult_StringErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_StringErrorZ)); return res; }
-	~CResult_StringErrorZ() { CResult_StringErrorZ_free(self); }
-	CResult_StringErrorZ& operator=(CResult_StringErrorZ&& o) { CResult_StringErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_StringErrorZ)); return *this; }
-	LDKCResult_StringErrorZ* operator &() { return &self; }
-	LDKCResult_StringErrorZ* operator ->() { return &self; }
-	const LDKCResult_StringErrorZ* operator &() const { return &self; }
-	const LDKCResult_StringErrorZ* operator ->() const { return &self; }
+	CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ(const CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ&) = delete;
+	CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ(CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ)); }
+	CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ)); }
+	operator LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ() && { LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ)); return res; }
+	~CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ() { CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(self); }
+	CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ& operator=(CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ&& o) { CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ)); return *this; }
+	LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* operator &() { return &self; }
+	LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* operator ->() { return &self; }
+	const LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* operator &() const { return &self; }
+	const LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* operator ->() const { return &self; }
 };
 class CResult_NoneErrorZ {
 private:
@@ -4931,6 +5568,21 @@ public:
 	const LDKCResult_NoneErrorZ* operator &() const { return &self; }
 	const LDKCResult_NoneErrorZ* operator ->() const { return &self; }
 };
+class CResult_StringErrorZ {
+private:
+	LDKCResult_StringErrorZ self;
+public:
+	CResult_StringErrorZ(const CResult_StringErrorZ&) = delete;
+	CResult_StringErrorZ(CResult_StringErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_StringErrorZ)); }
+	CResult_StringErrorZ(LDKCResult_StringErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_StringErrorZ)); }
+	operator LDKCResult_StringErrorZ() && { LDKCResult_StringErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_StringErrorZ)); return res; }
+	~CResult_StringErrorZ() { CResult_StringErrorZ_free(self); }
+	CResult_StringErrorZ& operator=(CResult_StringErrorZ&& o) { CResult_StringErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_StringErrorZ)); return *this; }
+	LDKCResult_StringErrorZ* operator &() { return &self; }
+	LDKCResult_StringErrorZ* operator ->() { return &self; }
+	const LDKCResult_StringErrorZ* operator &() const { return &self; }
+	const LDKCResult_StringErrorZ* operator ->() const { return &self; }
+};
 class C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ {
 private:
 	LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ self;
@@ -4946,6 +5598,21 @@ public:
 	const LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* operator &() const { return &self; }
 	const LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* operator ->() const { return &self; }
 };
+class CResult_PongDecodeErrorZ {
+private:
+	LDKCResult_PongDecodeErrorZ self;
+public:
+	CResult_PongDecodeErrorZ(const CResult_PongDecodeErrorZ&) = delete;
+	CResult_PongDecodeErrorZ(CResult_PongDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PongDecodeErrorZ)); }
+	CResult_PongDecodeErrorZ(LDKCResult_PongDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PongDecodeErrorZ)); }
+	operator LDKCResult_PongDecodeErrorZ() && { LDKCResult_PongDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PongDecodeErrorZ)); return res; }
+	~CResult_PongDecodeErrorZ() { CResult_PongDecodeErrorZ_free(self); }
+	CResult_PongDecodeErrorZ& operator=(CResult_PongDecodeErrorZ&& o) { CResult_PongDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PongDecodeErrorZ)); return *this; }
+	LDKCResult_PongDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_PongDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_PongDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_PongDecodeErrorZ* operator ->() const { return &self; }
+};
 class CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ {
 private:
 	LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ self;
@@ -4961,6 +5628,36 @@ public:
 	const LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* operator &() const { return &self; }
 	const LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* operator ->() const { return &self; }
 };
+class COption_EventZ {
+private:
+	LDKCOption_EventZ self;
+public:
+	COption_EventZ(const COption_EventZ&) = delete;
+	COption_EventZ(COption_EventZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_EventZ)); }
+	COption_EventZ(LDKCOption_EventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_EventZ)); }
+	operator LDKCOption_EventZ() && { LDKCOption_EventZ res = self; memset(&self, 0, sizeof(LDKCOption_EventZ)); return res; }
+	~COption_EventZ() { COption_EventZ_free(self); }
+	COption_EventZ& operator=(COption_EventZ&& o) { COption_EventZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_EventZ)); return *this; }
+	LDKCOption_EventZ* operator &() { return &self; }
+	LDKCOption_EventZ* operator ->() { return &self; }
+	const LDKCOption_EventZ* operator &() const { return &self; }
+	const LDKCOption_EventZ* operator ->() const { return &self; }
+};
+class CResult_ChannelTypeFeaturesDecodeErrorZ {
+private:
+	LDKCResult_ChannelTypeFeaturesDecodeErrorZ self;
+public:
+	CResult_ChannelTypeFeaturesDecodeErrorZ(const CResult_ChannelTypeFeaturesDecodeErrorZ&) = delete;
+	CResult_ChannelTypeFeaturesDecodeErrorZ(CResult_ChannelTypeFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelTypeFeaturesDecodeErrorZ)); }
+	CResult_ChannelTypeFeaturesDecodeErrorZ(LDKCResult_ChannelTypeFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelTypeFeaturesDecodeErrorZ)); }
+	operator LDKCResult_ChannelTypeFeaturesDecodeErrorZ() && { LDKCResult_ChannelTypeFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelTypeFeaturesDecodeErrorZ)); return res; }
+	~CResult_ChannelTypeFeaturesDecodeErrorZ() { CResult_ChannelTypeFeaturesDecodeErrorZ_free(self); }
+	CResult_ChannelTypeFeaturesDecodeErrorZ& operator=(CResult_ChannelTypeFeaturesDecodeErrorZ&& o) { CResult_ChannelTypeFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelTypeFeaturesDecodeErrorZ)); return *this; }
+	LDKCResult_ChannelTypeFeaturesDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_ChannelTypeFeaturesDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_ChannelTypeFeaturesDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_ChannelTypeFeaturesDecodeErrorZ* operator ->() const { return &self; }
+};
 class CVec_RouteHintZ {
 private:
 	LDKCVec_RouteHintZ self;
@@ -5021,6 +5718,21 @@ public:
 	const LDKCResult_TrustedCommitmentTransactionNoneZ* operator &() const { return &self; }
 	const LDKCResult_TrustedCommitmentTransactionNoneZ* operator ->() const { return &self; }
 };
+class CResult_FixedPenaltyScorerDecodeErrorZ {
+private:
+	LDKCResult_FixedPenaltyScorerDecodeErrorZ self;
+public:
+	CResult_FixedPenaltyScorerDecodeErrorZ(const CResult_FixedPenaltyScorerDecodeErrorZ&) = delete;
+	CResult_FixedPenaltyScorerDecodeErrorZ(CResult_FixedPenaltyScorerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FixedPenaltyScorerDecodeErrorZ)); }
+	CResult_FixedPenaltyScorerDecodeErrorZ(LDKCResult_FixedPenaltyScorerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ)); }
+	operator LDKCResult_FixedPenaltyScorerDecodeErrorZ() && { LDKCResult_FixedPenaltyScorerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ)); return res; }
+	~CResult_FixedPenaltyScorerDecodeErrorZ() { CResult_FixedPenaltyScorerDecodeErrorZ_free(self); }
+	CResult_FixedPenaltyScorerDecodeErrorZ& operator=(CResult_FixedPenaltyScorerDecodeErrorZ&& o) { CResult_FixedPenaltyScorerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FixedPenaltyScorerDecodeErrorZ)); return *this; }
+	LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator ->() const { return &self; }
+};
 class CResult_NoneLightningErrorZ {
 private:
 	LDKCResult_NoneLightningErrorZ self;
@@ -5051,20 +5763,20 @@ public:
 	const LDKCResult_NonePeerHandleErrorZ* operator &() const { return &self; }
 	const LDKCResult_NonePeerHandleErrorZ* operator ->() const { return &self; }
 };
-class COption_CVec_NetAddressZZ {
+class CResult_COption_EventZDecodeErrorZ {
 private:
-	LDKCOption_CVec_NetAddressZZ self;
+	LDKCResult_COption_EventZDecodeErrorZ self;
 public:
-	COption_CVec_NetAddressZZ(const COption_CVec_NetAddressZZ&) = delete;
-	COption_CVec_NetAddressZZ(COption_CVec_NetAddressZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_CVec_NetAddressZZ)); }
-	COption_CVec_NetAddressZZ(LDKCOption_CVec_NetAddressZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_CVec_NetAddressZZ)); }
-	operator LDKCOption_CVec_NetAddressZZ() && { LDKCOption_CVec_NetAddressZZ res = self; memset(&self, 0, sizeof(LDKCOption_CVec_NetAddressZZ)); return res; }
-	~COption_CVec_NetAddressZZ() { COption_CVec_NetAddressZZ_free(self); }
-	COption_CVec_NetAddressZZ& operator=(COption_CVec_NetAddressZZ&& o) { COption_CVec_NetAddressZZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_CVec_NetAddressZZ)); return *this; }
-	LDKCOption_CVec_NetAddressZZ* operator &() { return &self; }
-	LDKCOption_CVec_NetAddressZZ* operator ->() { return &self; }
-	const LDKCOption_CVec_NetAddressZZ* operator &() const { return &self; }
-	const LDKCOption_CVec_NetAddressZZ* operator ->() const { return &self; }
+	CResult_COption_EventZDecodeErrorZ(const CResult_COption_EventZDecodeErrorZ&) = delete;
+	CResult_COption_EventZDecodeErrorZ(CResult_COption_EventZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_EventZDecodeErrorZ)); }
+	CResult_COption_EventZDecodeErrorZ(LDKCResult_COption_EventZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_EventZDecodeErrorZ)); }
+	operator LDKCResult_COption_EventZDecodeErrorZ() && { LDKCResult_COption_EventZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_EventZDecodeErrorZ)); return res; }
+	~CResult_COption_EventZDecodeErrorZ() { CResult_COption_EventZDecodeErrorZ_free(self); }
+	CResult_COption_EventZDecodeErrorZ& operator=(CResult_COption_EventZDecodeErrorZ&& o) { CResult_COption_EventZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_EventZDecodeErrorZ)); return *this; }
+	LDKCResult_COption_EventZDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_COption_EventZDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_COption_EventZDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_COption_EventZDecodeErrorZ* operator ->() const { return &self; }
 };
 class CResult_CVec_SignatureZNoneZ {
 private:
@@ -5081,6 +5793,21 @@ public:
 	const LDKCResult_CVec_SignatureZNoneZ* operator &() const { return &self; }
 	const LDKCResult_CVec_SignatureZNoneZ* operator ->() const { return &self; }
 };
+class COption_CVec_NetAddressZZ {
+private:
+	LDKCOption_CVec_NetAddressZZ self;
+public:
+	COption_CVec_NetAddressZZ(const COption_CVec_NetAddressZZ&) = delete;
+	COption_CVec_NetAddressZZ(COption_CVec_NetAddressZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_CVec_NetAddressZZ)); }
+	COption_CVec_NetAddressZZ(LDKCOption_CVec_NetAddressZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_CVec_NetAddressZZ)); }
+	operator LDKCOption_CVec_NetAddressZZ() && { LDKCOption_CVec_NetAddressZZ res = self; memset(&self, 0, sizeof(LDKCOption_CVec_NetAddressZZ)); return res; }
+	~COption_CVec_NetAddressZZ() { COption_CVec_NetAddressZZ_free(self); }
+	COption_CVec_NetAddressZZ& operator=(COption_CVec_NetAddressZZ&& o) { COption_CVec_NetAddressZZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_CVec_NetAddressZZ)); return *this; }
+	LDKCOption_CVec_NetAddressZZ* operator &() { return &self; }
+	LDKCOption_CVec_NetAddressZZ* operator ->() { return &self; }
+	const LDKCOption_CVec_NetAddressZZ* operator &() const { return &self; }
+	const LDKCOption_CVec_NetAddressZZ* operator ->() const { return &self; }
+};
 class CResult__u832APIErrorZ {
 private:
 	LDKCResult__u832APIErrorZ self;
@@ -5096,6 +5823,21 @@ public:
 	const LDKCResult__u832APIErrorZ* operator &() const { return &self; }
 	const LDKCResult__u832APIErrorZ* operator ->() const { return &self; }
 };
+class CResult_PaymentIdPaymentErrorZ {
+private:
+	LDKCResult_PaymentIdPaymentErrorZ self;
+public:
+	CResult_PaymentIdPaymentErrorZ(const CResult_PaymentIdPaymentErrorZ&) = delete;
+	CResult_PaymentIdPaymentErrorZ(CResult_PaymentIdPaymentErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentIdPaymentErrorZ)); }
+	CResult_PaymentIdPaymentErrorZ(LDKCResult_PaymentIdPaymentErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentIdPaymentErrorZ)); }
+	operator LDKCResult_PaymentIdPaymentErrorZ() && { LDKCResult_PaymentIdPaymentErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentIdPaymentErrorZ)); return res; }
+	~CResult_PaymentIdPaymentErrorZ() { CResult_PaymentIdPaymentErrorZ_free(self); }
+	CResult_PaymentIdPaymentErrorZ& operator=(CResult_PaymentIdPaymentErrorZ&& o) { CResult_PaymentIdPaymentErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentIdPaymentErrorZ)); return *this; }
+	LDKCResult_PaymentIdPaymentErrorZ* operator &() { return &self; }
+	LDKCResult_PaymentIdPaymentErrorZ* operator ->() { return &self; }
+	const LDKCResult_PaymentIdPaymentErrorZ* operator &() const { return &self; }
+	const LDKCResult_PaymentIdPaymentErrorZ* operator ->() const { return &self; }
+};
 class CResult_DescriptionCreationErrorZ {
 private:
 	LDKCResult_DescriptionCreationErrorZ self;
@@ -5111,6 +5853,36 @@ public:
 	const LDKCResult_DescriptionCreationErrorZ* operator &() const { return &self; }
 	const LDKCResult_DescriptionCreationErrorZ* operator ->() const { return &self; }
 };
+class CResult_COption_MonitorEventZDecodeErrorZ {
+private:
+	LDKCResult_COption_MonitorEventZDecodeErrorZ self;
+public:
+	CResult_COption_MonitorEventZDecodeErrorZ(const CResult_COption_MonitorEventZDecodeErrorZ&) = delete;
+	CResult_COption_MonitorEventZDecodeErrorZ(CResult_COption_MonitorEventZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_MonitorEventZDecodeErrorZ)); }
+	CResult_COption_MonitorEventZDecodeErrorZ(LDKCResult_COption_MonitorEventZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ)); }
+	operator LDKCResult_COption_MonitorEventZDecodeErrorZ() && { LDKCResult_COption_MonitorEventZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ)); return res; }
+	~CResult_COption_MonitorEventZDecodeErrorZ() { CResult_COption_MonitorEventZDecodeErrorZ_free(self); }
+	CResult_COption_MonitorEventZDecodeErrorZ& operator=(CResult_COption_MonitorEventZDecodeErrorZ&& o) { CResult_COption_MonitorEventZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_MonitorEventZDecodeErrorZ)); return *this; }
+	LDKCResult_COption_MonitorEventZDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_COption_MonitorEventZDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_COption_MonitorEventZDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_COption_MonitorEventZDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_PayeePubKeyErrorZ {
+private:
+	LDKCResult_PayeePubKeyErrorZ self;
+public:
+	CResult_PayeePubKeyErrorZ(const CResult_PayeePubKeyErrorZ&) = delete;
+	CResult_PayeePubKeyErrorZ(CResult_PayeePubKeyErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PayeePubKeyErrorZ)); }
+	CResult_PayeePubKeyErrorZ(LDKCResult_PayeePubKeyErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PayeePubKeyErrorZ)); }
+	operator LDKCResult_PayeePubKeyErrorZ() && { LDKCResult_PayeePubKeyErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PayeePubKeyErrorZ)); return res; }
+	~CResult_PayeePubKeyErrorZ() { CResult_PayeePubKeyErrorZ_free(self); }
+	CResult_PayeePubKeyErrorZ& operator=(CResult_PayeePubKeyErrorZ&& o) { CResult_PayeePubKeyErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PayeePubKeyErrorZ)); return *this; }
+	LDKCResult_PayeePubKeyErrorZ* operator &() { return &self; }
+	LDKCResult_PayeePubKeyErrorZ* operator ->() { return &self; }
+	const LDKCResult_PayeePubKeyErrorZ* operator &() const { return &self; }
+	const LDKCResult_PayeePubKeyErrorZ* operator ->() const { return &self; }
+};
 class CVec_C2Tuple_PublicKeyTypeZZ {
 private:
 	LDKCVec_C2Tuple_PublicKeyTypeZZ self;
@@ -5141,21 +5913,6 @@ public:
 	const LDKCResult_RoutingFeesDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_RoutingFeesDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_PayeePubKeyErrorZ {
-private:
-	LDKCResult_PayeePubKeyErrorZ self;
-public:
-	CResult_PayeePubKeyErrorZ(const CResult_PayeePubKeyErrorZ&) = delete;
-	CResult_PayeePubKeyErrorZ(CResult_PayeePubKeyErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PayeePubKeyErrorZ)); }
-	CResult_PayeePubKeyErrorZ(LDKCResult_PayeePubKeyErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PayeePubKeyErrorZ)); }
-	operator LDKCResult_PayeePubKeyErrorZ() && { LDKCResult_PayeePubKeyErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PayeePubKeyErrorZ)); return res; }
-	~CResult_PayeePubKeyErrorZ() { CResult_PayeePubKeyErrorZ_free(self); }
-	CResult_PayeePubKeyErrorZ& operator=(CResult_PayeePubKeyErrorZ&& o) { CResult_PayeePubKeyErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PayeePubKeyErrorZ)); return *this; }
-	LDKCResult_PayeePubKeyErrorZ* operator &() { return &self; }
-	LDKCResult_PayeePubKeyErrorZ* operator ->() { return &self; }
-	const LDKCResult_PayeePubKeyErrorZ* operator &() const { return &self; }
-	const LDKCResult_PayeePubKeyErrorZ* operator ->() const { return &self; }
-};
 class CResult_QueryShortChannelIdsDecodeErrorZ {
 private:
 	LDKCResult_QueryShortChannelIdsDecodeErrorZ self;
@@ -5201,6 +5958,21 @@ public:
 	const LDKCResult_UpdateAddHTLCDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_UpdateAddHTLCDecodeErrorZ* operator ->() const { return &self; }
 };
+class CVec_PhantomRouteHintsZ {
+private:
+	LDKCVec_PhantomRouteHintsZ self;
+public:
+	CVec_PhantomRouteHintsZ(const CVec_PhantomRouteHintsZ&) = delete;
+	CVec_PhantomRouteHintsZ(CVec_PhantomRouteHintsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PhantomRouteHintsZ)); }
+	CVec_PhantomRouteHintsZ(LDKCVec_PhantomRouteHintsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PhantomRouteHintsZ)); }
+	operator LDKCVec_PhantomRouteHintsZ() && { LDKCVec_PhantomRouteHintsZ res = self; memset(&self, 0, sizeof(LDKCVec_PhantomRouteHintsZ)); return res; }
+	~CVec_PhantomRouteHintsZ() { CVec_PhantomRouteHintsZ_free(self); }
+	CVec_PhantomRouteHintsZ& operator=(CVec_PhantomRouteHintsZ&& o) { CVec_PhantomRouteHintsZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PhantomRouteHintsZ)); return *this; }
+	LDKCVec_PhantomRouteHintsZ* operator &() { return &self; }
+	LDKCVec_PhantomRouteHintsZ* operator ->() { return &self; }
+	const LDKCVec_PhantomRouteHintsZ* operator &() const { return &self; }
+	const LDKCVec_PhantomRouteHintsZ* operator ->() const { return &self; }
+};
 class CResult_CounterpartyChannelTransactionParametersDecodeErrorZ {
 private:
 	LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ self;
@@ -5246,6 +6018,21 @@ public:
 	const LDKCVec_NetAddressZ* operator &() const { return &self; }
 	const LDKCVec_NetAddressZ* operator ->() const { return &self; }
 };
+class CResult_ChannelDetailsDecodeErrorZ {
+private:
+	LDKCResult_ChannelDetailsDecodeErrorZ self;
+public:
+	CResult_ChannelDetailsDecodeErrorZ(const CResult_ChannelDetailsDecodeErrorZ&) = delete;
+	CResult_ChannelDetailsDecodeErrorZ(CResult_ChannelDetailsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelDetailsDecodeErrorZ)); }
+	CResult_ChannelDetailsDecodeErrorZ(LDKCResult_ChannelDetailsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelDetailsDecodeErrorZ)); }
+	operator LDKCResult_ChannelDetailsDecodeErrorZ() && { LDKCResult_ChannelDetailsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelDetailsDecodeErrorZ)); return res; }
+	~CResult_ChannelDetailsDecodeErrorZ() { CResult_ChannelDetailsDecodeErrorZ_free(self); }
+	CResult_ChannelDetailsDecodeErrorZ& operator=(CResult_ChannelDetailsDecodeErrorZ&& o) { CResult_ChannelDetailsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelDetailsDecodeErrorZ)); return *this; }
+	LDKCResult_ChannelDetailsDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_ChannelDetailsDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_ChannelDetailsDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_ChannelDetailsDecodeErrorZ* operator ->() const { return &self; }
+};
 class CVec_C2Tuple_usizeTransactionZZ {
 private:
 	LDKCVec_C2Tuple_usizeTransactionZZ self;
@@ -5276,6 +6063,21 @@ public:
 	const LDKCVec_PublicKeyZ* operator &() const { return &self; }
 	const LDKCVec_PublicKeyZ* operator ->() const { return &self; }
 };
+class COption_MonitorEventZ {
+private:
+	LDKCOption_MonitorEventZ self;
+public:
+	COption_MonitorEventZ(const COption_MonitorEventZ&) = delete;
+	COption_MonitorEventZ(COption_MonitorEventZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_MonitorEventZ)); }
+	COption_MonitorEventZ(LDKCOption_MonitorEventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_MonitorEventZ)); }
+	operator LDKCOption_MonitorEventZ() && { LDKCOption_MonitorEventZ res = self; memset(&self, 0, sizeof(LDKCOption_MonitorEventZ)); return res; }
+	~COption_MonitorEventZ() { COption_MonitorEventZ_free(self); }
+	COption_MonitorEventZ& operator=(COption_MonitorEventZ&& o) { COption_MonitorEventZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_MonitorEventZ)); return *this; }
+	LDKCOption_MonitorEventZ* operator &() { return &self; }
+	LDKCOption_MonitorEventZ* operator ->() { return &self; }
+	const LDKCOption_MonitorEventZ* operator &() const { return &self; }
+	const LDKCOption_MonitorEventZ* operator ->() const { return &self; }
+};
 class COption_TypeZ {
 private:
 	LDKCOption_TypeZ self;
@@ -5306,21 +6108,6 @@ public:
 	const LDKCResult_COption_TypeZDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_COption_TypeZDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_DirectionalChannelInfoDecodeErrorZ {
-private:
-	LDKCResult_DirectionalChannelInfoDecodeErrorZ self;
-public:
-	CResult_DirectionalChannelInfoDecodeErrorZ(const CResult_DirectionalChannelInfoDecodeErrorZ&) = delete;
-	CResult_DirectionalChannelInfoDecodeErrorZ(CResult_DirectionalChannelInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_DirectionalChannelInfoDecodeErrorZ)); }
-	CResult_DirectionalChannelInfoDecodeErrorZ(LDKCResult_DirectionalChannelInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_DirectionalChannelInfoDecodeErrorZ)); }
-	operator LDKCResult_DirectionalChannelInfoDecodeErrorZ() && { LDKCResult_DirectionalChannelInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_DirectionalChannelInfoDecodeErrorZ)); return res; }
-	~CResult_DirectionalChannelInfoDecodeErrorZ() { CResult_DirectionalChannelInfoDecodeErrorZ_free(self); }
-	CResult_DirectionalChannelInfoDecodeErrorZ& operator=(CResult_DirectionalChannelInfoDecodeErrorZ&& o) { CResult_DirectionalChannelInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_DirectionalChannelInfoDecodeErrorZ)); return *this; }
-	LDKCResult_DirectionalChannelInfoDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_DirectionalChannelInfoDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_DirectionalChannelInfoDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_DirectionalChannelInfoDecodeErrorZ* operator ->() const { return &self; }
-};
 class C2Tuple_u32TxOutZ {
 private:
 	LDKC2Tuple_u32TxOutZ self;
@@ -5351,6 +6138,21 @@ public:
 	const LDKCResult_UpdateFailHTLCDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_UpdateFailHTLCDecodeErrorZ* operator ->() const { return &self; }
 };
+class CResult_PaymentSecretNoneZ {
+private:
+	LDKCResult_PaymentSecretNoneZ self;
+public:
+	CResult_PaymentSecretNoneZ(const CResult_PaymentSecretNoneZ&) = delete;
+	CResult_PaymentSecretNoneZ(CResult_PaymentSecretNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentSecretNoneZ)); }
+	CResult_PaymentSecretNoneZ(LDKCResult_PaymentSecretNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentSecretNoneZ)); }
+	operator LDKCResult_PaymentSecretNoneZ() && { LDKCResult_PaymentSecretNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentSecretNoneZ)); return res; }
+	~CResult_PaymentSecretNoneZ() { CResult_PaymentSecretNoneZ_free(self); }
+	CResult_PaymentSecretNoneZ& operator=(CResult_PaymentSecretNoneZ&& o) { CResult_PaymentSecretNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentSecretNoneZ)); return *this; }
+	LDKCResult_PaymentSecretNoneZ* operator &() { return &self; }
+	LDKCResult_PaymentSecretNoneZ* operator ->() { return &self; }
+	const LDKCResult_PaymentSecretNoneZ* operator &() const { return &self; }
+	const LDKCResult_PaymentSecretNoneZ* operator ->() const { return &self; }
+};
 class CResult_ChannelConfigDecodeErrorZ {
 private:
 	LDKCResult_ChannelConfigDecodeErrorZ self;
@@ -5486,6 +6288,21 @@ public:
 	const LDKCVec_MonitorEventZ* operator &() const { return &self; }
 	const LDKCVec_MonitorEventZ* operator ->() const { return &self; }
 };
+class CVec_PaymentPreimageZ {
+private:
+	LDKCVec_PaymentPreimageZ self;
+public:
+	CVec_PaymentPreimageZ(const CVec_PaymentPreimageZ&) = delete;
+	CVec_PaymentPreimageZ(CVec_PaymentPreimageZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PaymentPreimageZ)); }
+	CVec_PaymentPreimageZ(LDKCVec_PaymentPreimageZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PaymentPreimageZ)); }
+	operator LDKCVec_PaymentPreimageZ() && { LDKCVec_PaymentPreimageZ res = self; memset(&self, 0, sizeof(LDKCVec_PaymentPreimageZ)); return res; }
+	~CVec_PaymentPreimageZ() { CVec_PaymentPreimageZ_free(self); }
+	CVec_PaymentPreimageZ& operator=(CVec_PaymentPreimageZ&& o) { CVec_PaymentPreimageZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PaymentPreimageZ)); return *this; }
+	LDKCVec_PaymentPreimageZ* operator &() { return &self; }
+	LDKCVec_PaymentPreimageZ* operator ->() { return &self; }
+	const LDKCVec_PaymentPreimageZ* operator &() const { return &self; }
+	const LDKCVec_PaymentPreimageZ* operator ->() const { return &self; }
+};
 class CVec_C2Tuple_u32ScriptZZ {
 private:
 	LDKCVec_C2Tuple_u32ScriptZZ self;
@@ -5516,6 +6333,21 @@ public:
 	const LDKCResult_NoneChannelMonitorUpdateErrZ* operator &() const { return &self; }
 	const LDKCResult_NoneChannelMonitorUpdateErrZ* operator ->() const { return &self; }
 };
+class CResult_COption_ClosureReasonZDecodeErrorZ {
+private:
+	LDKCResult_COption_ClosureReasonZDecodeErrorZ self;
+public:
+	CResult_COption_ClosureReasonZDecodeErrorZ(const CResult_COption_ClosureReasonZDecodeErrorZ&) = delete;
+	CResult_COption_ClosureReasonZDecodeErrorZ(CResult_COption_ClosureReasonZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_ClosureReasonZDecodeErrorZ)); }
+	CResult_COption_ClosureReasonZDecodeErrorZ(LDKCResult_COption_ClosureReasonZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ)); }
+	operator LDKCResult_COption_ClosureReasonZDecodeErrorZ() && { LDKCResult_COption_ClosureReasonZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ)); return res; }
+	~CResult_COption_ClosureReasonZDecodeErrorZ() { CResult_COption_ClosureReasonZDecodeErrorZ_free(self); }
+	CResult_COption_ClosureReasonZDecodeErrorZ& operator=(CResult_COption_ClosureReasonZDecodeErrorZ&& o) { CResult_COption_ClosureReasonZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_ClosureReasonZDecodeErrorZ)); return *this; }
+	LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator ->() const { return &self; }
+};
 class CResult_SiPrefixNoneZ {
 private:
 	LDKCResult_SiPrefixNoneZ self;
@@ -5576,6 +6408,51 @@ public:
 	const LDKCResult_NoneNoneZ* operator &() const { return &self; }
 	const LDKCResult_NoneNoneZ* operator ->() const { return &self; }
 };
+class CResult_RouteParametersDecodeErrorZ {
+private:
+	LDKCResult_RouteParametersDecodeErrorZ self;
+public:
+	CResult_RouteParametersDecodeErrorZ(const CResult_RouteParametersDecodeErrorZ&) = delete;
+	CResult_RouteParametersDecodeErrorZ(CResult_RouteParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteParametersDecodeErrorZ)); }
+	CResult_RouteParametersDecodeErrorZ(LDKCResult_RouteParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteParametersDecodeErrorZ)); }
+	operator LDKCResult_RouteParametersDecodeErrorZ() && { LDKCResult_RouteParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteParametersDecodeErrorZ)); return res; }
+	~CResult_RouteParametersDecodeErrorZ() { CResult_RouteParametersDecodeErrorZ_free(self); }
+	CResult_RouteParametersDecodeErrorZ& operator=(CResult_RouteParametersDecodeErrorZ&& o) { CResult_RouteParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteParametersDecodeErrorZ)); return *this; }
+	LDKCResult_RouteParametersDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_RouteParametersDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_RouteParametersDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_RouteParametersDecodeErrorZ* operator ->() const { return &self; }
+};
+class COption_ClosureReasonZ {
+private:
+	LDKCOption_ClosureReasonZ self;
+public:
+	COption_ClosureReasonZ(const COption_ClosureReasonZ&) = delete;
+	COption_ClosureReasonZ(COption_ClosureReasonZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_ClosureReasonZ)); }
+	COption_ClosureReasonZ(LDKCOption_ClosureReasonZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_ClosureReasonZ)); }
+	operator LDKCOption_ClosureReasonZ() && { LDKCOption_ClosureReasonZ res = self; memset(&self, 0, sizeof(LDKCOption_ClosureReasonZ)); return res; }
+	~COption_ClosureReasonZ() { COption_ClosureReasonZ_free(self); }
+	COption_ClosureReasonZ& operator=(COption_ClosureReasonZ&& o) { COption_ClosureReasonZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_ClosureReasonZ)); return *this; }
+	LDKCOption_ClosureReasonZ* operator &() { return &self; }
+	LDKCOption_ClosureReasonZ* operator ->() { return &self; }
+	const LDKCOption_ClosureReasonZ* operator &() const { return &self; }
+	const LDKCOption_ClosureReasonZ* operator ->() const { return &self; }
+};
+class CVec_APIErrorZ {
+private:
+	LDKCVec_APIErrorZ self;
+public:
+	CVec_APIErrorZ(const CVec_APIErrorZ&) = delete;
+	CVec_APIErrorZ(CVec_APIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_APIErrorZ)); }
+	CVec_APIErrorZ(LDKCVec_APIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_APIErrorZ)); }
+	operator LDKCVec_APIErrorZ() && { LDKCVec_APIErrorZ res = self; memset(&self, 0, sizeof(LDKCVec_APIErrorZ)); return res; }
+	~CVec_APIErrorZ() { CVec_APIErrorZ_free(self); }
+	CVec_APIErrorZ& operator=(CVec_APIErrorZ&& o) { CVec_APIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_APIErrorZ)); return *this; }
+	LDKCVec_APIErrorZ* operator &() { return &self; }
+	LDKCVec_APIErrorZ* operator ->() { return &self; }
+	const LDKCVec_APIErrorZ* operator &() const { return &self; }
+	const LDKCVec_APIErrorZ* operator ->() const { return &self; }
+};
 class CResult_PrivateRouteCreationErrorZ {
 private:
 	LDKCResult_PrivateRouteCreationErrorZ self;
@@ -5606,21 +6483,6 @@ public:
 	const LDKCResult_boolPeerHandleErrorZ* operator &() const { return &self; }
 	const LDKCResult_boolPeerHandleErrorZ* operator ->() const { return &self; }
 };
-class CVec_APIErrorZ {
-private:
-	LDKCVec_APIErrorZ self;
-public:
-	CVec_APIErrorZ(const CVec_APIErrorZ&) = delete;
-	CVec_APIErrorZ(CVec_APIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_APIErrorZ)); }
-	CVec_APIErrorZ(LDKCVec_APIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_APIErrorZ)); }
-	operator LDKCVec_APIErrorZ() && { LDKCVec_APIErrorZ res = self; memset(&self, 0, sizeof(LDKCVec_APIErrorZ)); return res; }
-	~CVec_APIErrorZ() { CVec_APIErrorZ_free(self); }
-	CVec_APIErrorZ& operator=(CVec_APIErrorZ&& o) { CVec_APIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_APIErrorZ)); return *this; }
-	LDKCVec_APIErrorZ* operator &() { return &self; }
-	LDKCVec_APIErrorZ* operator ->() { return &self; }
-	const LDKCVec_APIErrorZ* operator &() const { return &self; }
-	const LDKCVec_APIErrorZ* operator ->() const { return &self; }
-};
 class CResult_ChannelUpdateDecodeErrorZ {
 private:
 	LDKCResult_ChannelUpdateDecodeErrorZ self;
@@ -5696,6 +6558,21 @@ public:
 	const LDKCResult_NodeFeaturesDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_NodeFeaturesDecodeErrorZ* operator ->() const { return &self; }
 };
+class CVec_u5Z {
+private:
+	LDKCVec_u5Z self;
+public:
+	CVec_u5Z(const CVec_u5Z&) = delete;
+	CVec_u5Z(CVec_u5Z&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_u5Z)); }
+	CVec_u5Z(LDKCVec_u5Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_u5Z)); }
+	operator LDKCVec_u5Z() && { LDKCVec_u5Z res = self; memset(&self, 0, sizeof(LDKCVec_u5Z)); return res; }
+	~CVec_u5Z() { CVec_u5Z_free(self); }
+	CVec_u5Z& operator=(CVec_u5Z&& o) { CVec_u5Z_free(self); self = o.self; memset(&o, 0, sizeof(CVec_u5Z)); return *this; }
+	LDKCVec_u5Z* operator &() { return &self; }
+	LDKCVec_u5Z* operator ->() { return &self; }
+	const LDKCVec_u5Z* operator &() const { return &self; }
+	const LDKCVec_u5Z* operator ->() const { return &self; }
+};
 class CResult_InMemorySignerDecodeErrorZ {
 private:
 	LDKCResult_InMemorySignerDecodeErrorZ self;
@@ -5726,6 +6603,21 @@ public:
 	const LDKCResult_PaymentSecretAPIErrorZ* operator &() const { return &self; }
 	const LDKCResult_PaymentSecretAPIErrorZ* operator ->() const { return &self; }
 };
+class CResult_CounterpartyForwardingInfoDecodeErrorZ {
+private:
+	LDKCResult_CounterpartyForwardingInfoDecodeErrorZ self;
+public:
+	CResult_CounterpartyForwardingInfoDecodeErrorZ(const CResult_CounterpartyForwardingInfoDecodeErrorZ&) = delete;
+	CResult_CounterpartyForwardingInfoDecodeErrorZ(CResult_CounterpartyForwardingInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CounterpartyForwardingInfoDecodeErrorZ)); }
+	CResult_CounterpartyForwardingInfoDecodeErrorZ(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ)); }
+	operator LDKCResult_CounterpartyForwardingInfoDecodeErrorZ() && { LDKCResult_CounterpartyForwardingInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ)); return res; }
+	~CResult_CounterpartyForwardingInfoDecodeErrorZ() { CResult_CounterpartyForwardingInfoDecodeErrorZ_free(self); }
+	CResult_CounterpartyForwardingInfoDecodeErrorZ& operator=(CResult_CounterpartyForwardingInfoDecodeErrorZ&& o) { CResult_CounterpartyForwardingInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CounterpartyForwardingInfoDecodeErrorZ)); return *this; }
+	LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* operator ->() const { return &self; }
+};
 class C2Tuple_u32ScriptZ {
 private:
 	LDKC2Tuple_u32ScriptZ self;
@@ -5741,21 +6633,6 @@ public:
 	const LDKC2Tuple_u32ScriptZ* operator &() const { return &self; }
 	const LDKC2Tuple_u32ScriptZ* operator ->() const { return &self; }
 };
-class CResult_CResult_NetAddressu8ZDecodeErrorZ {
-private:
-	LDKCResult_CResult_NetAddressu8ZDecodeErrorZ self;
-public:
-	CResult_CResult_NetAddressu8ZDecodeErrorZ(const CResult_CResult_NetAddressu8ZDecodeErrorZ&) = delete;
-	CResult_CResult_NetAddressu8ZDecodeErrorZ(CResult_CResult_NetAddressu8ZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CResult_NetAddressu8ZDecodeErrorZ)); }
-	CResult_CResult_NetAddressu8ZDecodeErrorZ(LDKCResult_CResult_NetAddressu8ZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CResult_NetAddressu8ZDecodeErrorZ)); }
-	operator LDKCResult_CResult_NetAddressu8ZDecodeErrorZ() && { LDKCResult_CResult_NetAddressu8ZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CResult_NetAddressu8ZDecodeErrorZ)); return res; }
-	~CResult_CResult_NetAddressu8ZDecodeErrorZ() { CResult_CResult_NetAddressu8ZDecodeErrorZ_free(self); }
-	CResult_CResult_NetAddressu8ZDecodeErrorZ& operator=(CResult_CResult_NetAddressu8ZDecodeErrorZ&& o) { CResult_CResult_NetAddressu8ZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CResult_NetAddressu8ZDecodeErrorZ)); return *this; }
-	LDKCResult_CResult_NetAddressu8ZDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_CResult_NetAddressu8ZDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_CResult_NetAddressu8ZDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_CResult_NetAddressu8ZDecodeErrorZ* operator ->() const { return &self; }
-};
 class CResult_ReplyShortChannelIdsEndDecodeErrorZ {
 private:
 	LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ self;
@@ -5801,20 +6678,20 @@ public:
 	const LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ {
+class COption_NoneZ {
 private:
-	LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ self;
+	LDKCOption_NoneZ self;
 public:
-	CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ(const CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ&) = delete;
-	CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ(CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ)); }
-	CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ)); }
-	operator LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ() && { LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ)); return res; }
-	~CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ() { CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(self); }
-	CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ& operator=(CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ&& o) { CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ)); return *this; }
-	LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* operator ->() const { return &self; }
+	COption_NoneZ(const COption_NoneZ&) = delete;
+	COption_NoneZ(COption_NoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_NoneZ)); }
+	COption_NoneZ(LDKCOption_NoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_NoneZ)); }
+	operator LDKCOption_NoneZ() && { LDKCOption_NoneZ res = self; memset(&self, 0, sizeof(LDKCOption_NoneZ)); return res; }
+	~COption_NoneZ() { COption_NoneZ_free(self); }
+	COption_NoneZ& operator=(COption_NoneZ&& o) { COption_NoneZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_NoneZ)); return *this; }
+	LDKCOption_NoneZ* operator &() { return &self; }
+	LDKCOption_NoneZ* operator ->() { return &self; }
+	const LDKCOption_NoneZ* operator &() const { return &self; }
+	const LDKCOption_NoneZ* operator ->() const { return &self; }
 };
 class CVec_TxOutZ {
 private:
@@ -5831,6 +6708,51 @@ public:
 	const LDKCVec_TxOutZ* operator &() const { return &self; }
 	const LDKCVec_TxOutZ* operator ->() const { return &self; }
 };
+class CResult_ProbabilisticScoringParametersDecodeErrorZ {
+private:
+	LDKCResult_ProbabilisticScoringParametersDecodeErrorZ self;
+public:
+	CResult_ProbabilisticScoringParametersDecodeErrorZ(const CResult_ProbabilisticScoringParametersDecodeErrorZ&) = delete;
+	CResult_ProbabilisticScoringParametersDecodeErrorZ(CResult_ProbabilisticScoringParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ProbabilisticScoringParametersDecodeErrorZ)); }
+	CResult_ProbabilisticScoringParametersDecodeErrorZ(LDKCResult_ProbabilisticScoringParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ProbabilisticScoringParametersDecodeErrorZ)); }
+	operator LDKCResult_ProbabilisticScoringParametersDecodeErrorZ() && { LDKCResult_ProbabilisticScoringParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ProbabilisticScoringParametersDecodeErrorZ)); return res; }
+	~CResult_ProbabilisticScoringParametersDecodeErrorZ() { CResult_ProbabilisticScoringParametersDecodeErrorZ_free(self); }
+	CResult_ProbabilisticScoringParametersDecodeErrorZ& operator=(CResult_ProbabilisticScoringParametersDecodeErrorZ&& o) { CResult_ProbabilisticScoringParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ProbabilisticScoringParametersDecodeErrorZ)); return *this; }
+	LDKCResult_ProbabilisticScoringParametersDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_ProbabilisticScoringParametersDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_ProbabilisticScoringParametersDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_ProbabilisticScoringParametersDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ {
+private:
+	LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ self;
+public:
+	CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ(const CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ&) = delete;
+	CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ(CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ)); }
+	CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ)); }
+	operator LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ() && { LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ)); return res; }
+	~CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ() { CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(self); }
+	CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ& operator=(CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ&& o) { CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ)); return *this; }
+	LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_ChannelUpdateInfoDecodeErrorZ {
+private:
+	LDKCResult_ChannelUpdateInfoDecodeErrorZ self;
+public:
+	CResult_ChannelUpdateInfoDecodeErrorZ(const CResult_ChannelUpdateInfoDecodeErrorZ&) = delete;
+	CResult_ChannelUpdateInfoDecodeErrorZ(CResult_ChannelUpdateInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelUpdateInfoDecodeErrorZ)); }
+	CResult_ChannelUpdateInfoDecodeErrorZ(LDKCResult_ChannelUpdateInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ)); }
+	operator LDKCResult_ChannelUpdateInfoDecodeErrorZ() && { LDKCResult_ChannelUpdateInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ)); return res; }
+	~CResult_ChannelUpdateInfoDecodeErrorZ() { CResult_ChannelUpdateInfoDecodeErrorZ_free(self); }
+	CResult_ChannelUpdateInfoDecodeErrorZ& operator=(CResult_ChannelUpdateInfoDecodeErrorZ&& o) { CResult_ChannelUpdateInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelUpdateInfoDecodeErrorZ)); return *this; }
+	LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator ->() const { return &self; }
+};
 class CVec_UpdateFailHTLCZ {
 private:
 	LDKCVec_UpdateFailHTLCZ self;
@@ -5925,8 +6847,18 @@ inline void EventsProvider::process_pending_events(struct LDKEventHandler handle
 inline void EventHandler::handle_event(const struct LDKEvent *NONNULL_PTR event) {
 	(self.handle_event)(self.this_arg, event);
 }
-inline uint64_t Score::channel_penalty_msat(uint64_t short_channel_id) {
-	uint64_t ret = (self.channel_penalty_msat)(self.this_arg, short_channel_id);
+inline uint64_t Score::channel_penalty_msat(uint64_t short_channel_id, uint64_t send_amt_msat, uint64_t capacity_msat, const struct LDKNodeId *NONNULL_PTR source, const struct LDKNodeId *NONNULL_PTR target) {
+	uint64_t ret = (self.channel_penalty_msat)(self.this_arg, short_channel_id, send_amt_msat, capacity_msat, source, target);
+	return ret;
+}
+inline void Score::payment_path_failed(struct LDKCVec_RouteHopZ 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) {
+	(self.payment_path_successful)(self.this_arg, path);
+}
+inline LDK::Score LockableScore::lock() {
+	LDK::Score ret = (self.lock)(self.this_arg);
 	return ret;
 }
 inline LDKPublicKey BaseSign::get_per_commitment_point(uint64_t idx) {
@@ -5937,16 +6869,16 @@ inline LDKThirtyTwoBytes BaseSign::release_commitment_secret(uint64_t idx) {
 	LDKThirtyTwoBytes ret = (self.release_commitment_secret)(self.this_arg, idx);
 	return ret;
 }
-inline LDK::CResult_NoneNoneZ BaseSign::validate_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx) {
-	LDK::CResult_NoneNoneZ ret = (self.validate_holder_commitment)(self.this_arg, holder_tx);
+inline LDK::CResult_NoneNoneZ BaseSign::validate_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_PaymentPreimageZ preimages) {
+	LDK::CResult_NoneNoneZ ret = (self.validate_holder_commitment)(self.this_arg, holder_tx, preimages);
 	return ret;
 }
 inline LDKThirtyTwoBytes BaseSign::channel_keys_id() {
 	LDKThirtyTwoBytes ret = (self.channel_keys_id)(self.this_arg);
 	return ret;
 }
-inline LDK::CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ BaseSign::sign_counterparty_commitment(const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx) {
-	LDK::CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ ret = (self.sign_counterparty_commitment)(self.this_arg, commitment_tx);
+inline LDK::CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ BaseSign::sign_counterparty_commitment(const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx, struct LDKCVec_PaymentPreimageZ preimages) {
+	LDK::CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ ret = (self.sign_counterparty_commitment)(self.this_arg, commitment_tx, preimages);
 	return ret;
 }
 inline LDK::CResult_NoneNoneZ BaseSign::validate_counterparty_revocation(uint64_t idx, const uint8_t (*secret)[32]) {
@@ -5973,15 +6905,15 @@ inline LDK::CResult_SignatureNoneZ BaseSign::sign_closing_transaction(const stru
 	LDK::CResult_SignatureNoneZ ret = (self.sign_closing_transaction)(self.this_arg, closing_tx);
 	return ret;
 }
-inline LDK::CResult_SignatureNoneZ BaseSign::sign_channel_announcement(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg) {
-	LDK::CResult_SignatureNoneZ ret = (self.sign_channel_announcement)(self.this_arg, msg);
+inline LDK::CResult_C2Tuple_SignatureSignatureZNoneZ BaseSign::sign_channel_announcement(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg) {
+	LDK::CResult_C2Tuple_SignatureSignatureZNoneZ ret = (self.sign_channel_announcement)(self.this_arg, msg);
 	return ret;
 }
 inline void BaseSign::ready_channel(const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters) {
 	(self.ready_channel)(self.this_arg, channel_parameters);
 }
-inline LDKSecretKey KeysInterface::get_node_secret() {
-	LDKSecretKey ret = (self.get_node_secret)(self.this_arg);
+inline LDK::CResult_SecretKeyNoneZ KeysInterface::get_node_secret(enum LDKRecipient recipient) {
+	LDK::CResult_SecretKeyNoneZ ret = (self.get_node_secret)(self.this_arg, recipient);
 	return ret;
 }
 inline LDK::CVec_u8Z KeysInterface::get_destination_script() {
@@ -6004,8 +6936,12 @@ inline LDK::CResult_SignDecodeErrorZ KeysInterface::read_chan_signer(struct LDKu
 	LDK::CResult_SignDecodeErrorZ ret = (self.read_chan_signer)(self.this_arg, reader);
 	return ret;
 }
-inline LDK::CResult_RecoverableSignatureNoneZ KeysInterface::sign_invoice(struct LDKCVec_u8Z invoice_preimage) {
-	LDK::CResult_RecoverableSignatureNoneZ ret = (self.sign_invoice)(self.this_arg, invoice_preimage);
+inline LDK::CResult_RecoverableSignatureNoneZ KeysInterface::sign_invoice(struct LDKu8slice hrp_bytes, struct LDKCVec_u5Z invoice_data, enum LDKRecipient receipient) {
+	LDK::CResult_RecoverableSignatureNoneZ ret = (self.sign_invoice)(self.this_arg, hrp_bytes, invoice_data, receipient);
+	return ret;
+}
+inline LDKThirtyTwoBytes KeysInterface::get_inbound_payment_key_material() {
+	LDKThirtyTwoBytes ret = (self.get_inbound_payment_key_material)(self.this_arg);
 	return ret;
 }
 inline LDK::CResult_COption_TypeZDecodeErrorZ CustomMessageReader::read(uint16_t message_type, struct LDKu8slice buffer) {
@@ -6020,6 +6956,33 @@ inline LDK::Str Type::debug_str() {
 	LDK::Str ret = (self.debug_str)(self.this_arg);
 	return ret;
 }
+inline LDKPublicKey Payer::node_id() {
+	LDKPublicKey ret = (self.node_id)(self.this_arg);
+	return ret;
+}
+inline LDK::CVec_ChannelDetailsZ Payer::first_hops() {
+	LDK::CVec_ChannelDetailsZ ret = (self.first_hops)(self.this_arg);
+	return ret;
+}
+inline LDK::CResult_PaymentIdPaymentSendFailureZ Payer::send_payment(const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_hash, struct LDKThirtyTwoBytes payment_secret) {
+	LDK::CResult_PaymentIdPaymentSendFailureZ ret = (self.send_payment)(self.this_arg, route, payment_hash, payment_secret);
+	return ret;
+}
+inline LDK::CResult_PaymentIdPaymentSendFailureZ Payer::send_spontaneous_payment(const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_preimage) {
+	LDK::CResult_PaymentIdPaymentSendFailureZ ret = (self.send_spontaneous_payment)(self.this_arg, route, payment_preimage);
+	return ret;
+}
+inline LDK::CResult_NonePaymentSendFailureZ Payer::retry_payment(const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_id) {
+	LDK::CResult_NonePaymentSendFailureZ ret = (self.retry_payment)(self.this_arg, route, payment_id);
+	return ret;
+}
+inline void Payer::abandon_payment(struct LDKThirtyTwoBytes payment_id) {
+	(self.abandon_payment)(self.this_arg, payment_id);
+}
+inline LDK::CResult_RouteLightningErrorZ Router::find_route(struct LDKPublicKey payer, const struct LDKRouteParameters *NONNULL_PTR route_params, const uint8_t (*payment_hash)[32], struct LDKCVec_ChannelDetailsZ *first_hops, const struct LDKScore *NONNULL_PTR scorer) {
+	LDK::CResult_RouteLightningErrorZ ret = (self.find_route)(self.this_arg, payer, route_params, payment_hash, first_hops, scorer);
+	return ret;
+}
 inline LDK::CResult_NoneLightningErrorZ CustomMessageHandler::handle_custom_message(struct LDKType msg, struct LDKPublicKey sender_node_id) {
 	LDK::CResult_NoneLightningErrorZ ret = (self.handle_custom_message)(self.this_arg, msg, sender_node_id);
 	return ret;
@@ -6142,15 +7105,15 @@ inline LDK::CResult_NoneLightningErrorZ RoutingMessageHandler::handle_query_shor
 	LDK::CResult_NoneLightningErrorZ ret = (self.handle_query_short_channel_ids)(self.this_arg, their_node_id, msg);
 	return ret;
 }
-inline void Logger::log(const char *record) {
+inline void Logger::log(const struct LDKRecord *NONNULL_PTR record) {
 	(self.log)(self.this_arg, record);
 }
-inline LDK::CResult_NoneChannelMonitorUpdateErrZ Persist::persist_new_channel(struct LDKOutPoint id, const struct LDKChannelMonitor *NONNULL_PTR data) {
-	LDK::CResult_NoneChannelMonitorUpdateErrZ ret = (self.persist_new_channel)(self.this_arg, id, data);
+inline LDK::CResult_NoneChannelMonitorUpdateErrZ Persist::persist_new_channel(struct LDKOutPoint channel_id, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id) {
+	LDK::CResult_NoneChannelMonitorUpdateErrZ ret = (self.persist_new_channel)(self.this_arg, channel_id, data, update_id);
 	return ret;
 }
-inline LDK::CResult_NoneChannelMonitorUpdateErrZ Persist::update_persisted_channel(struct LDKOutPoint id, const struct LDKChannelMonitorUpdate *NONNULL_PTR update, const struct LDKChannelMonitor *NONNULL_PTR data) {
-	LDK::CResult_NoneChannelMonitorUpdateErrZ ret = (self.update_persisted_channel)(self.this_arg, id, update, data);
+inline LDK::CResult_NoneChannelMonitorUpdateErrZ Persist::update_persisted_channel(struct LDKOutPoint channel_id, const struct LDKChannelMonitorUpdate *NONNULL_PTR update, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id) {
+	LDK::CResult_NoneChannelMonitorUpdateErrZ ret = (self.update_persisted_channel)(self.this_arg, channel_id, update, data, update_id);
 	return ret;
 }
 }