X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning-c-bindings%2Finclude%2Flightningpp.hpp;h=ed9eda2d493fd95071228c1c2ad830984f8a4a7b;hb=HEAD;hp=30e57446b0291c607c21646bcb7db5c7806a4fb6;hpb=fd396cecbaf30cd771a268d2dcd4e9afa85e18e1;p=ldk-c-bindings

diff --git a/lightning-c-bindings/include/lightningpp.hpp b/lightning-c-bindings/include/lightningpp.hpp
index 30e5744..0f8d1d7 100644
--- a/lightning-c-bindings/include/lightningpp.hpp
+++ b/lightning-c-bindings/include/lightningpp.hpp
@@ -2,30 +2,35 @@
 namespace LDK {
 // Forward declarations
 class Str;
+class RefundMaybeWithDerivedMetadataBuilder;
 class Refund;
 class Retry;
 class RetryableSendFailure;
 class PaymentSendFailure;
+class Bolt12PaymentError;
 class ProbeSendFailure;
 class RecipientOnionFields;
+class InvoiceWithExplicitSigningPubkeyBuilder;
+class InvoiceWithDerivedSigningPubkeyBuilder;
 class UnsignedBolt12Invoice;
+class SignBolt12InvoiceFn;
 class Bolt12Invoice;
-class BlindedPayInfo;
 class DelayedPaymentOutputDescriptor;
 class StaticPaymentOutputDescriptor;
 class SpendableOutputDescriptor;
 class ChannelDerivationParameters;
 class HTLCDescriptor;
 class ChannelSigner;
-class EcdsaChannelSigner;
-class WriteableEcdsaChannelSigner;
 class Recipient;
 class EntropySource;
 class NodeSigner;
+class OutputSpender;
 class SignerProvider;
+class ChangeDestinationSource;
 class InMemorySigner;
 class KeysManager;
 class PhantomKeysManager;
+class RandomBytes;
 class BackgroundProcessor;
 class GossipSync;
 class DefaultRouter;
@@ -39,8 +44,14 @@ class Route;
 class RouteParameters;
 class PaymentParameters;
 class Payee;
-class RouteHint;
-class RouteHintHop;
+class FirstHopCandidate;
+class PublicHopCandidate;
+class PrivateHopCandidate;
+class BlindedPathCandidate;
+class OneHopBlindedPathCandidate;
+class CandidateRouteHop;
+class UntrustedString;
+class PrintableString;
 class ScoreLookUp;
 class ScoreUpdate;
 class Score;
@@ -61,15 +72,9 @@ class ChannelMonitorUpdateStatus;
 class Watch;
 class Filter;
 class WatchedOutput;
-class InitFeatures;
-class NodeFeatures;
-class ChannelFeatures;
-class Bolt11InvoiceFeatures;
-class OfferFeatures;
-class InvoiceRequestFeatures;
-class Bolt12InvoiceFeatures;
-class BlindedHopFeatures;
-class ChannelTypeFeatures;
+class OfferId;
+class OfferWithExplicitMetadataBuilder;
+class OfferWithDerivedMetadataBuilder;
 class Offer;
 class Amount;
 class Quantity;
@@ -82,10 +87,12 @@ class ChannelUpdateInfo;
 class ChannelInfo;
 class DirectedChannelInfo;
 class EffectiveCapacity;
-class RoutingFees;
+class NodeAnnouncementDetails;
 class NodeAnnouncementInfo;
 class NodeAlias;
 class NodeInfo;
+class ShortChannelIdError;
+class InboundHTLCErr;
 class AnchorDescriptor;
 class BumpTransactionEvent;
 class Input;
@@ -95,13 +102,13 @@ class CoinSelectionSource;
 class WalletSource;
 class Wallet;
 class BumpTransactionEventHandler;
+class PendingHTLCRouting;
+class BlindedForward;
+class PendingHTLCInfo;
+class BlindedFailure;
 class FailureCode;
 class ChannelManager;
 class ChainParameters;
-class CounterpartyForwardingInfo;
-class ChannelCounterparty;
-class ChannelDetails;
-class ChannelShutdownState;
 class RecentPaymentDetails;
 class PhantomRouteHints;
 class ChannelManagerReadArgs;
@@ -113,9 +120,12 @@ class ChannelConfigUpdate;
 class UserConfig;
 class APIError;
 class TaggedHash;
+class SignError;
+class EcdsaChannelSigner;
 class ChannelMonitorUpdate;
 class MonitorEvent;
 class HTLCUpdate;
+class BalanceSource;
 class Balance;
 class ChannelMonitor;
 class ExpandedKey;
@@ -124,28 +134,41 @@ class IgnoringMessageHandler;
 class ErroringMessageHandler;
 class MessageHandler;
 class SocketDescriptor;
+class PeerDetails;
 class PeerHandleError;
 class PeerManager;
+class GraphSyncError;
 class RapidGossipSync;
 class KVStore;
 class Persister;
 class MonitorUpdatingPersister;
+class InvoiceRequestWithExplicitPayerIdBuilder;
+class InvoiceRequestWithDerivedPayerIdBuilder;
 class UnsignedInvoiceRequest;
+class SignInvoiceRequestFn;
 class InvoiceRequest;
 class VerifiedInvoiceRequest;
+class InvoiceRequestFields;
 class DecodeError;
 class Init;
 class ErrorMessage;
 class WarningMessage;
 class Ping;
 class Pong;
+class CommonOpenChannelFields;
+class ChannelParameters;
 class OpenChannel;
 class OpenChannelV2;
+class CommonAcceptChannelFields;
 class AcceptChannel;
 class AcceptChannelV2;
 class FundingCreated;
 class FundingSigned;
 class ChannelReady;
+class Stfu;
+class SpliceInit;
+class SpliceAck;
+class SpliceLocked;
 class TxAddInput;
 class TxAddOutput;
 class TxRemoveInput;
@@ -163,6 +186,7 @@ class OnionMessage;
 class UpdateFulfillHTLC;
 class UpdateFailHTLC;
 class UpdateFailMalformedHTLC;
+class CommitmentSignedBatch;
 class CommitmentSigned;
 class RevokeAndACK;
 class UpdateFee;
@@ -188,12 +212,27 @@ class CommitmentUpdate;
 class ChannelMessageHandler;
 class RoutingMessageHandler;
 class OnionMessageHandler;
+class FinalOnionHopData;
+class OnionPacket;
+class TrampolineOnionPacket;
 class Level;
 class Record;
 class Logger;
+class InboundHTLCStateDetails;
+class InboundHTLCDetails;
+class OutboundHTLCStateDetails;
+class OutboundHTLCDetails;
+class CounterpartyForwardingInfo;
+class ChannelCounterparty;
+class ChannelDetails;
+class ChannelShutdownState;
 class FutureCallback;
 class Future;
 class Sleeper;
+class AsyncPaymentsMessageHandler;
+class AsyncPaymentsMessage;
+class HeldHtlcAvailable;
+class ReleaseHeldHtlc;
 class OffersMessageHandler;
 class OffersMessage;
 class HTLCClaim;
@@ -220,6 +259,7 @@ class FeeEstimator;
 class Packet;
 class ParsedOnionMessageContents;
 class OnionMessageContents;
+class FundingInfo;
 class PaymentPurpose;
 class ClaimedHTLC;
 class PathFailure;
@@ -230,7 +270,12 @@ class Event;
 class MessageSendEvent;
 class MessageSendEventsProvider;
 class EventsProvider;
+class ReplayEvent;
 class EventHandler;
+class Nonce;
+class RoutingFees;
+class RouteHint;
+class RouteHintHop;
 class Bolt11ParseError;
 class ParseOrSemanticError;
 class Bolt11Invoice;
@@ -255,56 +300,90 @@ class OutPoint;
 class BigSize;
 class Hostname;
 class TransactionU16LenLimited;
-class UntrustedString;
-class PrintableString;
+class ChannelId;
 class CustomMessageReader;
 class Type;
-class ForwardNode;
+class BlindedPayInfo;
+class BlindedPaymentPath;
+class PaymentForwardNode;
 class ForwardTlvs;
 class ReceiveTlvs;
 class PaymentRelay;
 class PaymentConstraints;
-class PaymentError;
-class ProbingError;
+class PaymentContext;
+class UnknownPaymentContext;
+class Bolt12OfferContext;
+class Bolt12RefundContext;
 class UtxoLookupError;
 class UtxoResult;
 class UtxoLookup;
 class UtxoFuture;
 class OnionMessenger;
+class Responder;
+class ResponseInstruction;
+class MessageSendInstructions;
 class MessageRouter;
 class DefaultMessageRouter;
 class OnionMessagePath;
 class Destination;
+class SendSuccess;
 class SendError;
 class CustomOnionMessageHandler;
 class PeeledOnion;
 class FilesystemStore;
-class BlindedPath;
+class InitFeatures;
+class NodeFeatures;
+class ChannelFeatures;
+class Bolt11InvoiceFeatures;
+class OfferFeatures;
+class InvoiceRequestFeatures;
+class Bolt12InvoiceFeatures;
+class BlindedHopFeatures;
+class ChannelTypeFeatures;
+class IntroductionNode;
+class Direction;
+class NodeIdLookUp;
+class EmptyNodeIdLookUp;
 class BlindedHop;
-class GraphSyncError;
 class InvoiceError;
 class ErroneousField;
-class MonitorUpdateId;
+class TrackedSpendableOutput;
+class OutputSpendStatus;
+class OutputSweeper;
+class SpendingDelay;
+class DelayedPaymentBasepoint;
+class DelayedPaymentKey;
+class HtlcBasepoint;
+class HtlcKey;
+class RevocationBasepoint;
+class RevocationKey;
 class Persist;
 class LockedChannelMonitor;
 class ChainMonitor;
-class CResult_LockedChannelMonitorNoneZ;
+class BlindedMessagePath;
+class NextMessageHop;
+class MessageForwardNode;
+class MessageContext;
+class OffersContext;
+class CResult_HtlcKeyDecodeErrorZ;
 class CResult_TransactionU16LenLimitedNoneZ;
-class CVec_C2Tuple_BlindedPayInfoBlindedPathZZ;
+class CVec_TrackedSpendableOutputZ;
+class CResult_LockedChannelMonitorNoneZ;
 class CResult_PhantomRouteHintsDecodeErrorZ;
 class CResult_FundingCreatedDecodeErrorZ;
 class CVec_C2Tuple_u32TxOutZZ;
 class CResult_RetryDecodeErrorZ;
-class CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ;
+class CResult_BlindedForwardDecodeErrorZ;
 class CResult_ChannelInfoDecodeErrorZ;
+class COption_PaymentContextZ;
 class COption_MaxDustHTLCExposureZ;
 class CResult_NoneSendErrorZ;
-class C2Tuple_CVec_u8ZusizeZ;
-class COption_OffersMessageZ;
+class CResult_CVec_u8ZPeerHandleErrorZ;
+class CResult_OnionPacketDecodeErrorZ;
 class COption_NetworkUpdateZ;
 class COption_u64Z;
-class CResult_CVec_u8ZPeerHandleErrorZ;
 class CResult_GossipTimestampFilterDecodeErrorZ;
+class C2Tuple_OnionMessageContentsResponseInstructionZ;
 class CResult_RouteHintDecodeErrorZ;
 class COption_FilterZ;
 class C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ;
@@ -316,148 +395,185 @@ class CResult_StaticPaymentOutputDescriptorDecodeErrorZ;
 class COption_u32Z;
 class CResult_RecipientOnionFieldsNoneZ;
 class C2Tuple__u1632_u1632Z;
+class CVec_C2Tuple_OffersMessageMessageSendInstructionsZZ;
+class C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ;
+class CResult_TransactionNoneZ;
 class CResult_CVec_StrZIOErrorZ;
+class CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ;
+class COption_ECDSASignatureZ;
 class CResult_ClosingSignedFeeRangeDecodeErrorZ;
-class CResult_TransactionNoneZ;
 class CResult_CommitmentSignedDecodeErrorZ;
 class CResult_CommitmentTransactionDecodeErrorZ;
-class CResult_ErrorMessageDecodeErrorZ;
+class CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ;
+class CResult_StfuDecodeErrorZ;
 class CResult_OpenChannelDecodeErrorZ;
+class CResult_ErrorMessageDecodeErrorZ;
 class COption_APIErrorZ;
+class CVec_PeerDetailsZ;
+class CResult_u64ShortChannelIdErrorZ;
 class CResult_QueryChannelRangeDecodeErrorZ;
-class CVec_TransactionZ;
 class CVec_InputZ;
 class CResult_ChannelFeaturesDecodeErrorZ;
 class CResult_ChannelReadyDecodeErrorZ;
+class CVec_TransactionZ;
 class CResult_UpdateFeeDecodeErrorZ;
 class CResult_NoneBolt11SemanticErrorZ;
+class CResult_RevocationBasepointDecodeErrorZ;
 class COption_OnionMessageContentsZ;
 class CResult_NoneRetryableSendFailureZ;
-class CResult_boolLightningErrorZ;
+class CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ;
 class CResult_NodeIdDecodeErrorZ;
+class CResult_boolLightningErrorZ;
 class CResult_ChannelShutdownStateDecodeErrorZ;
-class CResult_HTLCOutputInCommitmentDecodeErrorZ;
 class CResult_NodeAnnouncementInfoDecodeErrorZ;
-class CResult_ShutdownScriptInvalidShutdownScriptZ;
+class CResult_InvoiceRequestBolt12SemanticErrorZ;
 class CResult_COption_NetworkUpdateZDecodeErrorZ;
 class CVec_UpdateFailMalformedHTLCZ;
 class CResult_ShutdownScriptNoneZ;
-class COption_HTLCDestinationZ;
-class CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ;
+class CResult_PendingHTLCInfoInboundHTLCErrZ;
+class CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ;
+class CResult_PendingHTLCInfoDecodeErrorZ;
+class CResult_SpliceInitDecodeErrorZ;
+class CResult_HTLCOutputInCommitmentDecodeErrorZ;
 class CVec_RouteHopZ;
-class CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ;
+class CResult_ShutdownScriptInvalidShutdownScriptZ;
 class CResult_CVec_UtxoZNoneZ;
 class CResult_CVec_u8ZIOErrorZ;
-class C3Tuple_OffersMessageDestinationBlindedPathZ;
+class COption_HTLCDestinationZ;
+class CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ;
 class CVec_ThirtyTwoBytesZ;
 class CResult_ChannelMonitorUpdateStatusNoneZ;
 class CResult_ClosingSignedDecodeErrorZ;
-class CResult_NonePaymentErrorZ;
 class CVec_CResult_NoneAPIErrorZZ;
 class CResult_SchnorrSignatureNoneZ;
+class C2Tuple_ReleaseHeldHtlcResponseInstructionZ;
 class CResult_CounterpartyCommitmentSecretsDecodeErrorZ;
-class CResult_ReceiveTlvsDecodeErrorZ;
 class CResult_HTLCDescriptorDecodeErrorZ;
 class CVec_RecentPaymentDetailsZ;
 class CVec_RouteHintHopZ;
-class CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ;
 class CResult_UntrustedStringDecodeErrorZ;
-class CVec_U5Z;
+class CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ;
 class CResult_PaymentParametersDecodeErrorZ;
+class CResult_DelayedPaymentBasepointDecodeErrorZ;
 class C2Tuple_ThirtyTwoBytesChannelMonitorZ;
 class COption_U128Z;
 class C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ;
+class CVec_MessageForwardNodeZ;
 class CResult_TxAckRbfDecodeErrorZ;
 class CResult_Bolt11InvoiceBolt11SemanticErrorZ;
 class COption_UtxoLookupZ;
+class CResult__u832NoneZ;
 class CResult_PongDecodeErrorZ;
 class CResult_UnsignedChannelAnnouncementDecodeErrorZ;
-class C2Tuple_OutPointCVec_MonitorUpdateIdZZ;
+class CResult_ChannelIdAPIErrorZ;
 class CResult_CVec_u8ZNoneZ;
+class CVec_C2Tuple_ChannelIdPublicKeyZZ;
 class C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ;
 class CResult_ChannelTransactionParametersDecodeErrorZ;
-class CResult_WriteableEcdsaChannelSignerDecodeErrorZ;
+class CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ;
 class CResult_DelayedPaymentOutputDescriptorDecodeErrorZ;
 class CResult_InFlightHtlcsDecodeErrorZ;
+class CResult_CommitmentSignedBatchDecodeErrorZ;
 class CResult_COption_HTLCDestinationZDecodeErrorZ;
+class CResult_Bolt12OfferContextDecodeErrorZ;
 class CResult_ThirtyTwoBytesNoneZ;
-class C3Tuple_OnionMessageContentsDestinationBlindedPathZ;
 class C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ;
-class CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ;
+class CResult_SendSuccessSendErrorZ;
+class CResult_NoneReplayEventZ;
+class C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ;
 class CResult_BlindedHopDecodeErrorZ;
-class C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ;
-class CResult_FixedPenaltyScorerDecodeErrorZ;
-class CVec_BlindedPathZ;
 class CResult_NoneLightningErrorZ;
+class CResult_FixedPenaltyScorerDecodeErrorZ;
 class CResult_NonePeerHandleErrorZ;
 class CResult_TrustedCommitmentTransactionNoneZ;
+class CResult_FinalOnionHopDataDecodeErrorZ;
 class CResult_COption_EventZDecodeErrorZ;
-class CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ;
-class CResult_PaymentFailureReasonDecodeErrorZ;
 class COption_SocketAddressZ;
 class CResult_COption_MonitorEventZDecodeErrorZ;
 class COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ;
-class CResult_DescriptionCreationErrorZ;
+class CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ;
 class CResult_RoutingFeesDecodeErrorZ;
 class CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ;
+class CResult_DescriptionCreationErrorZ;
 class CResult_PaymentRelayDecodeErrorZ;
-class CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ;
 class CResult_QueryShortChannelIdsDecodeErrorZ;
 class CResult_VerifiedInvoiceRequestNoneZ;
 class CResult_UpdateAddHTLCDecodeErrorZ;
+class COption_OutboundHTLCStateDetailsZ;
 class COption_MonitorEventZ;
 class COption_TypeZ;
 class CResult_COption_TypeZDecodeErrorZ;
+class CResult_OfferDecodeErrorZ;
 class CResult_COption_PathFailureZDecodeErrorZ;
 class CResult_Bolt11InvoiceSignOrCreationErrorZ;
+class CResult_BlindedMessagePathNoneZ;
 class CResult_UpdateFailHTLCDecodeErrorZ;
+class CResult_BlindedPaymentPathNoneZ;
+class CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ;
 class CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ;
-class CResult_RevokeAndACKDecodeErrorZ;
 class CResult_SpendableOutputDescriptorDecodeErrorZ;
-class C2Tuple_PublicKeyCOption_SocketAddressZZ;
+class CResult_RevokeAndACKDecodeErrorZ;
 class CResult_UnsignedChannelUpdateDecodeErrorZ;
 class CResult_PayeePubKeySecp256k1ErrorZ;
+class C2Tuple__u832u16Z;
+class CResult_BlindedMessagePathDecodeErrorZ;
+class CResult_CVec_BlindedMessagePathZNoneZ;
 class COption_BigEndianScalarZ;
+class CVec_ChannelIdZ;
 class CResult_PublicKeySecp256k1ErrorZ;
-class CResult_CVec_ECDSASignatureZNoneZ;
+class C2Tuple_OnionMessageContentsMessageSendInstructionsZ;
 class CVec_BlindedHopZ;
+class CResult_ReleaseHeldHtlcDecodeErrorZ;
+class CResult_CVec_ECDSASignatureZNoneZ;
 class CResult_COption_ClosureReasonZDecodeErrorZ;
-class CResult_InvoiceErrorDecodeErrorZ;
 class C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ;
+class CResult_NonceDecodeErrorZ;
 class CResult_RouteParametersDecodeErrorZ;
 class CResult_PrivateRouteCreationErrorZ;
+class CResult_InvoiceErrorDecodeErrorZ;
 class CResult_NodeAliasDecodeErrorZ;
+class C2Tuple_BestBlockOutputSweeperZ;
+class C2Tuple_OutPointCVec_u64ZZ;
 class CVec_UpdateFulfillHTLCZ;
 class CVec_C2Tuple_u32CVec_u8ZZZ;
+class C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ;
 class CResult_AnnouncementSignaturesDecodeErrorZ;
-class CResult_UpdateFulfillHTLCDecodeErrorZ;
 class CResult_TxCompleteDecodeErrorZ;
-class CResult_StrSecp256k1ErrorZ;
+class CResult_UpdateFulfillHTLCDecodeErrorZ;
 class CResult_NodeFeaturesDecodeErrorZ;
 class CResult_InMemorySignerDecodeErrorZ;
 class CResult_TxSignaturesDecodeErrorZ;
 class CVec_HTLCDescriptorZ;
 class CResult_ReplyShortChannelIdsEndDecodeErrorZ;
 class COption_PathFailureZ;
+class COption_MessageContextZ;
 class CVec_ECDSASignatureZ;
 class CResult_ChannelUpdateInfoDecodeErrorZ;
 class CVec_UpdateFailHTLCZ;
 class CVec_TxOutZ;
+class CVec_InboundHTLCDetailsZ;
+class CVec_OutboundHTLCDetailsZ;
 class CResult_BuiltCommitmentTransactionDecodeErrorZ;
+class CVec_PaymentForwardNodeZ;
+class CResult_TrackedSpendableOutputDecodeErrorZ;
 class CVec_SpendableOutputDescriptorZ;
+class CResult_ResponderDecodeErrorZ;
 class C2Tuple_OutPointCVec_u8ZZ;
+class CResult_WitnessNoneZ;
 class COption_C2Tuple_u64u64ZZ;
 class CResult_ChannelAnnouncementDecodeErrorZ;
-class CResult_PeeledOnionNoneZ;
 class CResult_HTLCUpdateDecodeErrorZ;
 class CResult_TxAddInputDecodeErrorZ;
-class CVec_OutPointZ;
+class CResult_HeldHtlcAvailableDecodeErrorZ;
 class CResult_TxInitRbfDecodeErrorZ;
 class COption_WriteableScoreZ;
 class CVec_StrZ;
+class CResult_AsyncPaymentsMessageDecodeErrorZ;
+class CResult_SpliceAckDecodeErrorZ;
 class CResult_PositiveTimestampCreationErrorZ;
+class CResult_PeeledOnionNoneZ;
+class CVec_C2Tuple_OutPointChannelIdZZ;
 class CResult_ChannelMonitorUpdateDecodeErrorZ;
-class C2Tuple_BlindedPayInfoBlindedPathZ;
 class CResult_ReplyChannelRangeDecodeErrorZ;
 class CResult_UnsignedNodeAnnouncementDecodeErrorZ;
 class CResult_TrustedClosingTransactionNoneZ;
@@ -466,41 +582,47 @@ class C2Tuple_PublicKeyTypeZ;
 class CResult_TxRemoveOutputDecodeErrorZ;
 class CResult_ChannelReestablishDecodeErrorZ;
 class CResult_OnionMessageDecodeErrorZ;
-class CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ;
-class CResult_C2Tuple_CVec_u8ZusizeZNoneZ;
 class CResult_Bolt11InvoiceParseOrSemanticErrorZ;
+class CResult_MessageContextDecodeErrorZ;
 class CResult_InitFeaturesDecodeErrorZ;
 class CResult_PublicKeyNoneZ;
 class CResult_PingDecodeErrorZ;
+class CResult_RevocationKeyDecodeErrorZ;
+class C2Tuple_OffersMessageMessageSendInstructionsZ;
 class CResult_BlindedHopFeaturesDecodeErrorZ;
+class CResult_ChannelIdDecodeErrorZ;
 class CVec_TransactionOutputsZ;
 class COption_HTLCClaimZ;
 class COption_boolZ;
-class CVec_CVec_u8ZZ;
+class CVec_BlindedPaymentPathZ;
 class CResult_ProbabilisticScorerDecodeErrorZ;
-class CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ;
 class COption_StrZ;
-class CResult_ShutdownScriptDecodeErrorZ;
+class CResult_CVec_BlindedPaymentPathZNoneZ;
+class COption_C2Tuple_OffersMessageResponseInstructionZZ;
 class C2Tuple_usizeTransactionZ;
+class COption_OffersContextZ;
 class CResult_NodeAnnouncementDecodeErrorZ;
-class CVec_FutureZ;
 class CVec_ChannelMonitorZ;
 class CResult_AcceptChannelV2DecodeErrorZ;
-class CResult_TxCreationKeysDecodeErrorZ;
+class CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ;
 class CResult_RouteHopDecodeErrorZ;
+class CResult_OfferIdDecodeErrorZ;
 class CVec_HTLCOutputInCommitmentZ;
 class CResult_CoinSelectionNoneZ;
-class C2Tuple_ThirtyTwoBytesPublicKeyZ;
-class CResult_SiPrefixBolt11ParseErrorZ;
-class CResult_BlindedPathDecodeErrorZ;
-class CVec_BalanceZ;
+class CVec_FutureZ;
+class CResult_TxCreationKeysDecodeErrorZ;
+class CResult_RefundBolt12SemanticErrorZ;
 class CResult_NoneIOErrorZ;
 class CResult_MaxDustHTLCExposureDecodeErrorZ;
+class CVec_BalanceZ;
 class CVec_CommitmentTransactionZ;
 class CResult_FundingSignedDecodeErrorZ;
 class CResult_RecoverableSignatureNoneZ;
 class CResult_SocketAddressDecodeErrorZ;
 class C2Tuple_Z;
+class CResult_ShutdownScriptDecodeErrorZ;
+class CResult_InboundHTLCDetailsDecodeErrorZ;
+class CResult_SiPrefixBolt11ParseErrorZ;
 class C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ;
 class CVec_PathZ;
 class CResult_NetworkGraphDecodeErrorZ;
@@ -514,73 +636,97 @@ class CResult_ChannelPublicKeysDecodeErrorZ;
 class CVec_ClaimedHTLCZ;
 class COption_CVec_ThirtyTwoBytesZZ;
 class CVec_SocketAddressZ;
+class CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ;
 class CResult_ThirtyTwoBytesPaymentSendFailureZ;
-class CResult_HolderCommitmentTransactionDecodeErrorZ;
 class CResult_WarningMessageDecodeErrorZ;
 class CResult_ChannelCounterpartyDecodeErrorZ;
-class CResult_InitDecodeErrorZ;
+class CResult_HolderCommitmentTransactionDecodeErrorZ;
+class CResult_DelayedPaymentKeyDecodeErrorZ;
+class C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ;
+class CResult_OfferBolt12SemanticErrorZ;
 class CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ;
-class CResult_ClaimedHTLCDecodeErrorZ;
+class CResult_InitDecodeErrorZ;
 class CResult_PaymentPurposeDecodeErrorZ;
-class CVec_MonitorUpdateIdZ;
+class CResult_ClaimedHTLCDecodeErrorZ;
 class CResult_OutPointDecodeErrorZ;
 class CVec_ChannelDetailsZ;
 class CResult_Bolt11InvoiceFeaturesDecodeErrorZ;
 class CVec_MessageSendEventZ;
+class CVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ;
 class CResult_RouteHintHopDecodeErrorZ;
+class CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ;
 class CResult_UpdateFailMalformedHTLCDecodeErrorZ;
 class CResult_BlindedPayInfoDecodeErrorZ;
 class CResult_ThirtyTwoBytesAPIErrorZ;
 class COption_ChannelShutdownStateZ;
-class CResult_CVec_CVec_u8ZZNoneZ;
+class CResult_Bolt12InvoiceBolt12SemanticErrorZ;
+class CResult_InvoiceRequestFieldsDecodeErrorZ;
 class CResult_AcceptChannelDecodeErrorZ;
+class CResult_RefundDecodeErrorZ;
 class CResult_HostnameDecodeErrorZ;
 class C2Tuple_u64u16Z;
 class COption_ThirtyTwoBytesZ;
 class CVec_u64Z;
 class CResult_NoneBolt12SemanticErrorZ;
-class COption_SecretKeyZ;
-class CResult_ThirtyTwoBytesPaymentErrorZ;
+class CResult_UnknownPaymentContextDecodeErrorZ;
+class COption_InboundHTLCStateDetailsZ;
+class CResult_OutputSweeperDecodeErrorZ;
+class CResult_C2Tuple_CVec_u8Zu64ZNoneZ;
 class COption_EventZ;
 class CResult_ChannelTypeFeaturesDecodeErrorZ;
 class COption_CVec_SocketAddressZZ;
 class CVec_RouteHintZ;
 class COption_u16Z;
 class COption_PaymentFailureReasonZ;
+class CResult_Bolt12RefundContextDecodeErrorZ;
 class CResult_ECDSASignatureNoneZ;
-class CVec_WitnessZ;
+class C2Tuple_ChannelIdPublicKeyZ;
+class C2Tuple_OffersMessageResponseInstructionZ;
+class CResult_EcdsaChannelSignerDecodeErrorZ;
 class CResult_BlindedTailDecodeErrorZ;
-class CResult_SocketAddressSocketAddressParseErrorZ;
+class CVec_WitnessZ;
 class COption_C2Tuple_u64u16ZZ;
-class CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ;
+class CResult_SocketAddressSocketAddressParseErrorZ;
+class CResult_COption_PaymentFailureReasonZDecodeErrorZ;
 class CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ;
 class CResult_ChannelDerivationParametersDecodeErrorZ;
-class CResult_PaymentConstraintsDecodeErrorZ;
+class CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ;
+class CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ;
+class CResult_OnionMessagePathNoneZ;
 class C2Tuple_u32CVec_u8ZZ;
 class CVec_C2Tuple_PublicKeyTypeZZ;
-class CResult_OnionMessagePathNoneZ;
+class CResult_OutboundHTLCDetailsDecodeErrorZ;
 class CResult_RefundBolt12ParseErrorZ;
-class C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ;
-class CVec_C2Tuple_u64CVec_u8ZZZ;
 class CResult_u32GraphSyncErrorZ;
-class CVec_PhantomRouteHintsZ;
+class CVec_C2Tuple_u64CVec_u8ZZZ;
+class CResult_OffersMessageDecodeErrorZ;
+class CResult_PaymentConstraintsDecodeErrorZ;
 class CResult_NoneAPIErrorZ;
 class CResult_Bolt12InvoiceFeaturesDecodeErrorZ;
 class COption_f64Z;
-class CResult_ChannelDetailsDecodeErrorZ;
+class CResult_TxRemoveInputDecodeErrorZ;
 class CVec_PublicKeyZ;
+class C2Tuple_CVec_u8Zu64Z;
 class CVec_C2Tuple_usizeTransactionZZ;
-class CResult_TxRemoveInputDecodeErrorZ;
 class CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ;
-class CResult_OffersMessageDecodeErrorZ;
+class CResult_Bolt12InvoiceDecodeErrorZ;
 class C2Tuple_u64u64Z;
-class CResult_CounterpartyChannelTransactionParametersDecodeErrorZ;
+class COption_NodeAnnouncementInfoZ;
+class CResult_PendingHTLCRoutingDecodeErrorZ;
+class COption_C2Tuple_OnionMessageContentsResponseInstructionZZ;
 class CResult_RecipientOnionFieldsDecodeErrorZ;
 class C2Tuple_u32TxOutZ;
+class CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ;
+class CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ;
+class CResult_ChannelDetailsDecodeErrorZ;
 class CVec_UtxoZ;
+class CResult_CounterpartyChannelTransactionParametersDecodeErrorZ;
 class CResult_ChannelConfigDecodeErrorZ;
 class CVec_PrivateRouteZ;
 class COption_i64Z;
+class CResult_PaymentContextDecodeErrorZ;
+class CVec_PhantomRouteHintsZ;
+class CVec_C2Tuple_OutPointCVec_u64ZZZ;
 class C2Tuple_ThirtyTwoBytesChannelManagerZ;
 class CResult_COption_OnionMessageContentsZDecodeErrorZ;
 class C2Tuple_u64CVec_u8ZZ;
@@ -590,27 +736,38 @@ class CVec_MonitorEventZ;
 class CResult_ShutdownDecodeErrorZ;
 class CResult_BigSizeDecodeErrorZ;
 class CResult_TxOutUtxoLookupErrorZ;
-class CResult_BlindedPathNoneZ;
 class COption_usizeZ;
-class CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ;
+class CVec_BlindedMessagePathZ;
+class CResult_OffersContextDecodeErrorZ;
 class CResult_NoneNoneZ;
 class CResult_boolPeerHandleErrorZ;
 class CResult_ChannelUpdateDecodeErrorZ;
 class CVec_APIErrorZ;
 class COption_TxOutZ;
 class COption_ClosureReasonZ;
+class CVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ;
 class CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ;
 class CResult_TransactionU16LenLimitedDecodeErrorZ;
+class CResult_FundingInfoDecodeErrorZ;
+class COption_AmountZ;
+class COption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ;
 class CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ;
-class CResult_CounterpartyForwardingInfoDecodeErrorZ;
 class CResult_OpenChannelV2DecodeErrorZ;
+class CResult_BestBlockDecodeErrorZ;
 class CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ;
-class C2Tuple_PublicKeyOnionMessageZ;
+class CResult_CounterpartyForwardingInfoDecodeErrorZ;
+class CResult_OutputSpendStatusDecodeErrorZ;
+class C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ;
 class CResult_RouteDecodeErrorZ;
+class CResult_BlindedFailureDecodeErrorZ;
 class CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ;
 class COption_NoneZ;
-class CResult_TxAddOutputDecodeErrorZ;
+class CResult_SpliceLockedDecodeErrorZ;
 class COption_CVec_u8ZZ;
+class COption_QuantityZ;
+class CResult_TxAddOutputDecodeErrorZ;
+class CResult_HtlcBasepointDecodeErrorZ;
+class C2Tuple_OutPointChannelIdZ;
 
 class Str {
 private:
@@ -627,6 +784,21 @@ public:
 	const LDKStr* operator &() const { return &self; }
 	const LDKStr* operator ->() const { return &self; }
 };
+class RefundMaybeWithDerivedMetadataBuilder {
+private:
+	LDKRefundMaybeWithDerivedMetadataBuilder self;
+public:
+	RefundMaybeWithDerivedMetadataBuilder(const RefundMaybeWithDerivedMetadataBuilder&) = delete;
+	RefundMaybeWithDerivedMetadataBuilder(RefundMaybeWithDerivedMetadataBuilder&& o) : self(o.self) { memset(&o, 0, sizeof(RefundMaybeWithDerivedMetadataBuilder)); }
+	RefundMaybeWithDerivedMetadataBuilder(LDKRefundMaybeWithDerivedMetadataBuilder&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRefundMaybeWithDerivedMetadataBuilder)); }
+	operator LDKRefundMaybeWithDerivedMetadataBuilder() && { LDKRefundMaybeWithDerivedMetadataBuilder res = self; memset(&self, 0, sizeof(LDKRefundMaybeWithDerivedMetadataBuilder)); return res; }
+	~RefundMaybeWithDerivedMetadataBuilder() { RefundMaybeWithDerivedMetadataBuilder_free(self); }
+	RefundMaybeWithDerivedMetadataBuilder& operator=(RefundMaybeWithDerivedMetadataBuilder&& o) { RefundMaybeWithDerivedMetadataBuilder_free(self); self = o.self; memset(&o, 0, sizeof(RefundMaybeWithDerivedMetadataBuilder)); return *this; }
+	LDKRefundMaybeWithDerivedMetadataBuilder* operator &() { return &self; }
+	LDKRefundMaybeWithDerivedMetadataBuilder* operator ->() { return &self; }
+	const LDKRefundMaybeWithDerivedMetadataBuilder* operator &() const { return &self; }
+	const LDKRefundMaybeWithDerivedMetadataBuilder* operator ->() const { return &self; }
+};
 class Refund {
 private:
 	LDKRefund self;
@@ -686,6 +858,21 @@ public:
 	const LDKPaymentSendFailure* operator &() const { return &self; }
 	const LDKPaymentSendFailure* operator ->() const { return &self; }
 };
+class Bolt12PaymentError {
+private:
+	LDKBolt12PaymentError self;
+public:
+	Bolt12PaymentError(const Bolt12PaymentError&) = delete;
+	Bolt12PaymentError(Bolt12PaymentError&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt12PaymentError)); }
+	Bolt12PaymentError(LDKBolt12PaymentError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt12PaymentError)); }
+	operator LDKBolt12PaymentError() && { LDKBolt12PaymentError res = self; memset(&self, 0, sizeof(LDKBolt12PaymentError)); return res; }
+	~Bolt12PaymentError() { Bolt12PaymentError_free(self); }
+	Bolt12PaymentError& operator=(Bolt12PaymentError&& o) { Bolt12PaymentError_free(self); self = o.self; memset(&o, 0, sizeof(Bolt12PaymentError)); return *this; }
+	LDKBolt12PaymentError* operator &() { return &self; }
+	LDKBolt12PaymentError* operator ->() { return &self; }
+	const LDKBolt12PaymentError* operator &() const { return &self; }
+	const LDKBolt12PaymentError* operator ->() const { return &self; }
+};
 class ProbeSendFailure {
 private:
 	LDKProbeSendFailure self;
@@ -716,6 +903,36 @@ public:
 	const LDKRecipientOnionFields* operator &() const { return &self; }
 	const LDKRecipientOnionFields* operator ->() const { return &self; }
 };
+class InvoiceWithExplicitSigningPubkeyBuilder {
+private:
+	LDKInvoiceWithExplicitSigningPubkeyBuilder self;
+public:
+	InvoiceWithExplicitSigningPubkeyBuilder(const InvoiceWithExplicitSigningPubkeyBuilder&) = delete;
+	InvoiceWithExplicitSigningPubkeyBuilder(InvoiceWithExplicitSigningPubkeyBuilder&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceWithExplicitSigningPubkeyBuilder)); }
+	InvoiceWithExplicitSigningPubkeyBuilder(LDKInvoiceWithExplicitSigningPubkeyBuilder&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceWithExplicitSigningPubkeyBuilder)); }
+	operator LDKInvoiceWithExplicitSigningPubkeyBuilder() && { LDKInvoiceWithExplicitSigningPubkeyBuilder res = self; memset(&self, 0, sizeof(LDKInvoiceWithExplicitSigningPubkeyBuilder)); return res; }
+	~InvoiceWithExplicitSigningPubkeyBuilder() { InvoiceWithExplicitSigningPubkeyBuilder_free(self); }
+	InvoiceWithExplicitSigningPubkeyBuilder& operator=(InvoiceWithExplicitSigningPubkeyBuilder&& o) { InvoiceWithExplicitSigningPubkeyBuilder_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceWithExplicitSigningPubkeyBuilder)); return *this; }
+	LDKInvoiceWithExplicitSigningPubkeyBuilder* operator &() { return &self; }
+	LDKInvoiceWithExplicitSigningPubkeyBuilder* operator ->() { return &self; }
+	const LDKInvoiceWithExplicitSigningPubkeyBuilder* operator &() const { return &self; }
+	const LDKInvoiceWithExplicitSigningPubkeyBuilder* operator ->() const { return &self; }
+};
+class InvoiceWithDerivedSigningPubkeyBuilder {
+private:
+	LDKInvoiceWithDerivedSigningPubkeyBuilder self;
+public:
+	InvoiceWithDerivedSigningPubkeyBuilder(const InvoiceWithDerivedSigningPubkeyBuilder&) = delete;
+	InvoiceWithDerivedSigningPubkeyBuilder(InvoiceWithDerivedSigningPubkeyBuilder&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceWithDerivedSigningPubkeyBuilder)); }
+	InvoiceWithDerivedSigningPubkeyBuilder(LDKInvoiceWithDerivedSigningPubkeyBuilder&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceWithDerivedSigningPubkeyBuilder)); }
+	operator LDKInvoiceWithDerivedSigningPubkeyBuilder() && { LDKInvoiceWithDerivedSigningPubkeyBuilder res = self; memset(&self, 0, sizeof(LDKInvoiceWithDerivedSigningPubkeyBuilder)); return res; }
+	~InvoiceWithDerivedSigningPubkeyBuilder() { InvoiceWithDerivedSigningPubkeyBuilder_free(self); }
+	InvoiceWithDerivedSigningPubkeyBuilder& operator=(InvoiceWithDerivedSigningPubkeyBuilder&& o) { InvoiceWithDerivedSigningPubkeyBuilder_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceWithDerivedSigningPubkeyBuilder)); return *this; }
+	LDKInvoiceWithDerivedSigningPubkeyBuilder* operator &() { return &self; }
+	LDKInvoiceWithDerivedSigningPubkeyBuilder* operator ->() { return &self; }
+	const LDKInvoiceWithDerivedSigningPubkeyBuilder* operator &() const { return &self; }
+	const LDKInvoiceWithDerivedSigningPubkeyBuilder* operator ->() const { return &self; }
+};
 class UnsignedBolt12Invoice {
 private:
 	LDKUnsignedBolt12Invoice self;
@@ -731,6 +948,25 @@ public:
 	const LDKUnsignedBolt12Invoice* operator &() const { return &self; }
 	const LDKUnsignedBolt12Invoice* operator ->() const { return &self; }
 };
+class SignBolt12InvoiceFn {
+private:
+	LDKSignBolt12InvoiceFn self;
+public:
+	SignBolt12InvoiceFn(const SignBolt12InvoiceFn&) = delete;
+	SignBolt12InvoiceFn(SignBolt12InvoiceFn&& o) : self(o.self) { memset(&o, 0, sizeof(SignBolt12InvoiceFn)); }
+	SignBolt12InvoiceFn(LDKSignBolt12InvoiceFn&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignBolt12InvoiceFn)); }
+	operator LDKSignBolt12InvoiceFn() && { LDKSignBolt12InvoiceFn res = self; memset(&self, 0, sizeof(LDKSignBolt12InvoiceFn)); return res; }
+	~SignBolt12InvoiceFn() { SignBolt12InvoiceFn_free(self); }
+	SignBolt12InvoiceFn& operator=(SignBolt12InvoiceFn&& o) { SignBolt12InvoiceFn_free(self); self = o.self; memset(&o, 0, sizeof(SignBolt12InvoiceFn)); return *this; }
+	LDKSignBolt12InvoiceFn* operator &() { return &self; }
+	LDKSignBolt12InvoiceFn* operator ->() { return &self; }
+	const LDKSignBolt12InvoiceFn* operator &() const { return &self; }
+	const LDKSignBolt12InvoiceFn* operator ->() const { return &self; }
+	/**
+	 *  Signs a [`TaggedHash`] computed over the merkle root of `message`'s TLV stream.
+	 */
+	inline LDK::CResult_SchnorrSignatureNoneZ sign_invoice(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR message);
+};
 class Bolt12Invoice {
 private:
 	LDKBolt12Invoice self;
@@ -746,21 +982,6 @@ public:
 	const LDKBolt12Invoice* operator &() const { return &self; }
 	const LDKBolt12Invoice* operator ->() const { return &self; }
 };
-class BlindedPayInfo {
-private:
-	LDKBlindedPayInfo self;
-public:
-	BlindedPayInfo(const BlindedPayInfo&) = delete;
-	BlindedPayInfo(BlindedPayInfo&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedPayInfo)); }
-	BlindedPayInfo(LDKBlindedPayInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedPayInfo)); }
-	operator LDKBlindedPayInfo() && { LDKBlindedPayInfo res = self; memset(&self, 0, sizeof(LDKBlindedPayInfo)); return res; }
-	~BlindedPayInfo() { BlindedPayInfo_free(self); }
-	BlindedPayInfo& operator=(BlindedPayInfo&& o) { BlindedPayInfo_free(self); self = o.self; memset(&o, 0, sizeof(BlindedPayInfo)); return *this; }
-	LDKBlindedPayInfo* operator &() { return &self; }
-	LDKBlindedPayInfo* operator ->() { return &self; }
-	const LDKBlindedPayInfo* operator &() const { return &self; }
-	const LDKBlindedPayInfo* operator ->() const { return &self; }
-};
 class DelayedPaymentOutputDescriptor {
 private:
 	LDKDelayedPaymentOutputDescriptor self;
@@ -854,8 +1075,13 @@ public:
 	 *  Gets the per-commitment point for a specific commitment number
 	 * 
 	 *  Note that the commitment number starts at `(1 << 48) - 1` and counts backwards.
+	 * 
+	 *  If the signer returns `Err`, then the user is responsible for either force-closing the channel
+	 *  or calling `ChannelManager::signer_unblocked` (this method is only available when the
+	 *  `async_signing` cfg flag is enabled) once the signature is ready.
+	 * 
 	 */
-	inline LDKPublicKey get_per_commitment_point(uint64_t idx);
+	inline LDK::CResult_PublicKeyNoneZ get_per_commitment_point(uint64_t idx);
 	/**
 	 *  Gets the commitment secret for a specific commitment number as part of the revocation process
 	 * 
@@ -866,7 +1092,7 @@ public:
 	 * 
 	 *  Note that the commitment number starts at `(1 << 48) - 1` and counts backwards.
 	 */
-	inline LDKThirtyTwoBytes release_commitment_secret(uint64_t idx);
+	inline LDK::CResult__u832NoneZ release_commitment_secret(uint64_t idx);
 	/**
 	 *  Validate the counterparty's signatures on the holder commitment transaction and HTLCs.
 	 * 
@@ -875,14 +1101,21 @@ 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.
+	 *  The preimages of outbound 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 that all the relevant preimages will be provided, but there may also be additional
 	 *  irrelevant or duplicate preimages.
 	 */
-	inline LDK::CResult_NoneNoneZ validate_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_ThirtyTwoBytesZ preimages);
+	inline LDK::CResult_NoneNoneZ validate_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_ThirtyTwoBytesZ outbound_htlc_preimages);
+	/**
+	 *  Validate the counterparty's revocation.
+	 * 
+	 *  This is required in order for the signer to make sure that the state has moved
+	 *  forward and it is safe to sign the next counterparty commitment.
+	 */
+	inline LDK::CResult_NoneNoneZ validate_counterparty_revocation(uint64_t idx, const uint8_t (*secret)[32]);
 	/**
 	 *  Returns an arbitrary identifier describing the set of keys which are provided back to you in
 	 *  some [`SpendableOutputDescriptor`] types. This should be sufficient to identify this
@@ -902,246 +1135,86 @@ public:
 	 */
 	inline void provide_channel_parameters(const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters);
 };
-class EcdsaChannelSigner {
+class Recipient {
 private:
-	LDKEcdsaChannelSigner self;
+	LDKRecipient self;
 public:
-	EcdsaChannelSigner(const EcdsaChannelSigner&) = delete;
-	EcdsaChannelSigner(EcdsaChannelSigner&& o) : self(o.self) { memset(&o, 0, sizeof(EcdsaChannelSigner)); }
-	EcdsaChannelSigner(LDKEcdsaChannelSigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEcdsaChannelSigner)); }
-	operator LDKEcdsaChannelSigner() && { LDKEcdsaChannelSigner res = self; memset(&self, 0, sizeof(LDKEcdsaChannelSigner)); return res; }
-	~EcdsaChannelSigner() { EcdsaChannelSigner_free(self); }
-	EcdsaChannelSigner& operator=(EcdsaChannelSigner&& o) { EcdsaChannelSigner_free(self); self = o.self; memset(&o, 0, sizeof(EcdsaChannelSigner)); return *this; }
-	LDKEcdsaChannelSigner* operator &() { return &self; }
-	LDKEcdsaChannelSigner* operator ->() { return &self; }
-	const LDKEcdsaChannelSigner* operator &() const { return &self; }
-	const LDKEcdsaChannelSigner* operator ->() const { return &self; }
+	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 EntropySource {
+private:
+	LDKEntropySource self;
+public:
+	EntropySource(const EntropySource&) = delete;
+	EntropySource(EntropySource&& o) : self(o.self) { memset(&o, 0, sizeof(EntropySource)); }
+	EntropySource(LDKEntropySource&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEntropySource)); }
+	operator LDKEntropySource() && { LDKEntropySource res = self; memset(&self, 0, sizeof(LDKEntropySource)); return res; }
+	~EntropySource() { EntropySource_free(self); }
+	EntropySource& operator=(EntropySource&& o) { EntropySource_free(self); self = o.self; memset(&o, 0, sizeof(EntropySource)); return *this; }
+	LDKEntropySource* operator &() { return &self; }
+	LDKEntropySource* operator ->() { return &self; }
+	const LDKEntropySource* operator &() const { return &self; }
+	const LDKEntropySource* operator ->() const { return &self; }
 	/**
-	 *  Create a signature for a counterparty's commitment transaction and associated HTLC transactions.
-	 * 
-	 *  Note that if signing fails or is rejected, the channel will be force-closed.
+	 *  Gets a unique, cryptographically-secure, random 32-byte value. This method must return a
+	 *  different value each time it is called.
+	 */
+	inline LDKThirtyTwoBytes get_secure_random_bytes();
+};
+class NodeSigner {
+private:
+	LDKNodeSigner self;
+public:
+	NodeSigner(const NodeSigner&) = delete;
+	NodeSigner(NodeSigner&& o) : self(o.self) { memset(&o, 0, sizeof(NodeSigner)); }
+	NodeSigner(LDKNodeSigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeSigner)); }
+	operator LDKNodeSigner() && { LDKNodeSigner res = self; memset(&self, 0, sizeof(LDKNodeSigner)); return res; }
+	~NodeSigner() { NodeSigner_free(self); }
+	NodeSigner& operator=(NodeSigner&& o) { NodeSigner_free(self); self = o.self; memset(&o, 0, sizeof(NodeSigner)); return *this; }
+	LDKNodeSigner* operator &() { return &self; }
+	LDKNodeSigner* operator ->() { return &self; }
+	const LDKNodeSigner* operator &() const { return &self; }
+	const LDKNodeSigner* operator ->() const { return &self; }
+	/**
+	 *  Get secret key material as bytes for use in encrypting and decrypting inbound payment data.
 	 * 
-	 *  Policy checks should be implemented in this function, including checking the amount
-	 *  sent to us and checking the HTLCs.
+	 *  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.
 	 * 
-	 *  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.
+	 *  This method must return the same value each time it is called.
 	 * 
-	 *  Note that all the relevant preimages will be provided, but there may also be additional
-	 *  irrelevant or duplicate preimages.
+	 *  [phantom node payments]: PhantomKeysManager
 	 */
-	inline LDK::CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ sign_counterparty_commitment(const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx, struct LDKCVec_ThirtyTwoBytesZ preimages);
+	inline LDKThirtyTwoBytes get_inbound_payment_key_material();
 	/**
-	 *  Validate the counterparty's revocation.
+	 *  Get node id based on the provided [`Recipient`].
 	 * 
-	 *  This is required in order for the signer to make sure that the state has moved
-	 *  forward and it is safe to sign the next counterparty commitment.
+	 *  This method must return the same value each time it is called with a given [`Recipient`]
+	 *  parameter.
+	 * 
+	 *  Errors if the [`Recipient`] variant is not supported by the implementation.
 	 */
-	inline LDK::CResult_NoneNoneZ validate_counterparty_revocation(uint64_t idx, const uint8_t (*secret)[32]);
+	inline LDK::CResult_PublicKeyNoneZ get_node_id(enum LDKRecipient recipient);
 	/**
-	 *  Creates a signature for a holder's commitment transaction.
-	 * 
-	 *  This will be called
-	 *  - with a non-revoked `commitment_tx`.
-	 *  - with the latest `commitment_tx` when we initiate a force-close.
+	 *  Gets the ECDH shared secret of our node secret and `other_key`, multiplying by `tweak` if
+	 *  one is provided. Note that this tweak can be applied to `other_key` instead of our node
+	 *  secret, though this is less efficient.
 	 * 
-	 *  This may be called multiple times for the same transaction.
+	 *  Note that if this fails while attempting to forward an HTLC, LDK will panic. The error
+	 *  should be resolved to allow LDK to resume forwarding HTLCs.
 	 * 
-	 *  An external signer implementation should check that the commitment has not been revoked.
+	 *  Errors if the [`Recipient`] variant is not supported by the implementation.
 	 */
-	inline LDK::CResult_ECDSASignatureNoneZ sign_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx);
-	/**
-	 *  Create a signature for the given input in a transaction spending an HTLC transaction output
-	 *  or a commitment transaction `to_local` output when our counterparty broadcasts an old state.
-	 * 
-	 *  A justice transaction may claim multiple outputs at the same time if timelocks are
-	 *  similar, but only a signature for the input at index `input` should be signed for here.
-	 *  It may be called multiple times for same output(s) if a fee-bump is needed with regards
-	 *  to an upcoming timelock expiration.
-	 * 
-	 *  Amount is value of the output spent by this input, committed to in the BIP 143 signature.
-	 * 
-	 *  `per_commitment_key` is revocation secret which was provided by our counterparty when they
-	 *  revoked the state which they eventually broadcast. It's not a _holder_ secret key and does
-	 *  not allow the spending of any funds by itself (you need our holder `revocation_secret` to do
-	 *  so).
-	 */
-	inline LDK::CResult_ECDSASignatureNoneZ sign_justice_revoked_output(struct LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (*per_commitment_key)[32]);
-	/**
-	 *  Create a signature for the given input in a transaction spending a commitment transaction
-	 *  HTLC output when our counterparty broadcasts an old state.
-	 * 
-	 *  A justice transaction may claim multiple outputs at the same time if timelocks are
-	 *  similar, but only a signature for the input at index `input` should be signed for here.
-	 *  It may be called multiple times for same output(s) if a fee-bump is needed with regards
-	 *  to an upcoming timelock expiration.
-	 * 
-	 *  `amount` is the value of the output spent by this input, committed to in the BIP 143
-	 *  signature.
-	 * 
-	 *  `per_commitment_key` is revocation secret which was provided by our counterparty when they
-	 *  revoked the state which they eventually broadcast. It's not a _holder_ secret key and does
-	 *  not allow the spending of any funds by itself (you need our holder revocation_secret to do
-	 *  so).
-	 * 
-	 *  `htlc` holds HTLC elements (hash, timelock), thus changing the format of the witness script
-	 *  (which is committed to in the BIP 143 signatures).
-	 */
-	inline LDK::CResult_ECDSASignatureNoneZ sign_justice_revoked_htlc(struct LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (*per_commitment_key)[32], const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc);
-	/**
-	 *  Computes the signature for a commitment transaction's HTLC output used as an input within
-	 *  `htlc_tx`, which spends the commitment transaction at index `input`. The signature returned
-	 *  must be be computed using [`EcdsaSighashType::All`].
-	 * 
-	 *  Note that this may be called for HTLCs in the penultimate commitment transaction if a
-	 *  [`ChannelMonitor`] [replica](https://github.com/lightningdevkit/rust-lightning/blob/main/GLOSSARY.md#monitor-replicas)
-	 *  broadcasts it before receiving the update for the latest commitment transaction.
-	 * 
-	 *  [`EcdsaSighashType::All`]: bitcoin::blockdata::transaction::EcdsaSighashType::All
-	 *  [`ChannelMonitor`]: crate::chain::channelmonitor::ChannelMonitor
-	 */
-	inline LDK::CResult_ECDSASignatureNoneZ sign_holder_htlc_transaction(struct LDKTransaction htlc_tx, uintptr_t input, const struct LDKHTLCDescriptor *NONNULL_PTR htlc_descriptor);
-	/**
-	 *  Create a signature for a claiming transaction for a HTLC output on a counterparty's commitment
-	 *  transaction, either offered or received.
-	 * 
-	 *  Such a transaction may claim multiples offered outputs at same time if we know the
-	 *  preimage for each when we create it, but only the input at index `input` should be
-	 *  signed for here. It may be called multiple times for same output(s) if a fee-bump is
-	 *  needed with regards to an upcoming timelock expiration.
-	 * 
-	 *  `witness_script` is either an offered or received script as defined in BOLT3 for HTLC
-	 *  outputs.
-	 * 
-	 *  `amount` is value of the output spent by this input, committed to in the BIP 143 signature.
-	 * 
-	 *  `per_commitment_point` is the dynamic point corresponding to the channel state
-	 *  detected onchain. It has been generated by our counterparty and is used to derive
-	 *  channel state keys, which are then included in the witness script and committed to in the
-	 *  BIP 143 signature.
-	 */
-	inline LDK::CResult_ECDSASignatureNoneZ sign_counterparty_htlc_transaction(struct LDKTransaction htlc_tx, uintptr_t input, uint64_t amount, struct LDKPublicKey per_commitment_point, const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc);
-	/**
-	 *  Create a signature for a (proposed) closing transaction.
-	 * 
-	 *  Note that, due to rounding, there may be one "missing" satoshi, and either party may have
-	 *  chosen to forgo their output as dust.
-	 */
-	inline LDK::CResult_ECDSASignatureNoneZ sign_closing_transaction(const struct LDKClosingTransaction *NONNULL_PTR closing_tx);
-	/**
-	 *  Computes the signature for a commitment transaction's anchor output used as an
-	 *  input within `anchor_tx`, which spends the commitment transaction, at index `input`.
-	 */
-	inline LDK::CResult_ECDSASignatureNoneZ sign_holder_anchor_input(struct LDKTransaction anchor_tx, uintptr_t input);
-	/**
-	 *  Signs a channel announcement message with our funding key proving it comes from one of the
-	 *  channel participants.
-	 * 
-	 *  Channel announcements also require a signature from each node's network key. Our node
-	 *  signature is computed through [`NodeSigner::sign_gossip_message`].
-	 * 
-	 *  Note that if this fails or is rejected, the channel will not be publicly announced and
-	 *  our counterparty may (though likely will not) close the channel on us for violating the
-	 *  protocol.
-	 */
-	inline LDK::CResult_ECDSASignatureNoneZ sign_channel_announcement_with_funding_key(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg);
-};
-class WriteableEcdsaChannelSigner {
-private:
-	LDKWriteableEcdsaChannelSigner self;
-public:
-	WriteableEcdsaChannelSigner(const WriteableEcdsaChannelSigner&) = delete;
-	WriteableEcdsaChannelSigner(WriteableEcdsaChannelSigner&& o) : self(o.self) { memset(&o, 0, sizeof(WriteableEcdsaChannelSigner)); }
-	WriteableEcdsaChannelSigner(LDKWriteableEcdsaChannelSigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWriteableEcdsaChannelSigner)); }
-	operator LDKWriteableEcdsaChannelSigner() && { LDKWriteableEcdsaChannelSigner res = self; memset(&self, 0, sizeof(LDKWriteableEcdsaChannelSigner)); return res; }
-	~WriteableEcdsaChannelSigner() { WriteableEcdsaChannelSigner_free(self); }
-	WriteableEcdsaChannelSigner& operator=(WriteableEcdsaChannelSigner&& o) { WriteableEcdsaChannelSigner_free(self); self = o.self; memset(&o, 0, sizeof(WriteableEcdsaChannelSigner)); return *this; }
-	LDKWriteableEcdsaChannelSigner* operator &() { return &self; }
-	LDKWriteableEcdsaChannelSigner* operator ->() { return &self; }
-	const LDKWriteableEcdsaChannelSigner* operator &() const { return &self; }
-	const LDKWriteableEcdsaChannelSigner* operator ->() const { return &self; }
-};
-class Recipient {
-private:
-	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 EntropySource {
-private:
-	LDKEntropySource self;
-public:
-	EntropySource(const EntropySource&) = delete;
-	EntropySource(EntropySource&& o) : self(o.self) { memset(&o, 0, sizeof(EntropySource)); }
-	EntropySource(LDKEntropySource&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEntropySource)); }
-	operator LDKEntropySource() && { LDKEntropySource res = self; memset(&self, 0, sizeof(LDKEntropySource)); return res; }
-	~EntropySource() { EntropySource_free(self); }
-	EntropySource& operator=(EntropySource&& o) { EntropySource_free(self); self = o.self; memset(&o, 0, sizeof(EntropySource)); return *this; }
-	LDKEntropySource* operator &() { return &self; }
-	LDKEntropySource* operator ->() { return &self; }
-	const LDKEntropySource* operator &() const { return &self; }
-	const LDKEntropySource* operator ->() const { return &self; }
-	/**
-	 *  Gets a unique, cryptographically-secure, random 32-byte value. This method must return a
-	 *  different value each time it is called.
-	 */
-	inline LDKThirtyTwoBytes get_secure_random_bytes();
-};
-class NodeSigner {
-private:
-	LDKNodeSigner self;
-public:
-	NodeSigner(const NodeSigner&) = delete;
-	NodeSigner(NodeSigner&& o) : self(o.self) { memset(&o, 0, sizeof(NodeSigner)); }
-	NodeSigner(LDKNodeSigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeSigner)); }
-	operator LDKNodeSigner() && { LDKNodeSigner res = self; memset(&self, 0, sizeof(LDKNodeSigner)); return res; }
-	~NodeSigner() { NodeSigner_free(self); }
-	NodeSigner& operator=(NodeSigner&& o) { NodeSigner_free(self); self = o.self; memset(&o, 0, sizeof(NodeSigner)); return *this; }
-	LDKNodeSigner* operator &() { return &self; }
-	LDKNodeSigner* operator ->() { return &self; }
-	const LDKNodeSigner* operator &() const { return &self; }
-	const LDKNodeSigner* operator ->() const { return &self; }
-	/**
-	 *  Get 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 LDKThirtyTwoBytes get_inbound_payment_key_material();
-	/**
-	 *  Get node id based on the provided [`Recipient`].
-	 * 
-	 *  This method must return the same value each time it is called with a given [`Recipient`]
-	 *  parameter.
-	 * 
-	 *  Errors if the [`Recipient`] variant is not supported by the implementation.
-	 */
-	inline LDK::CResult_PublicKeyNoneZ get_node_id(enum LDKRecipient recipient);
-	/**
-	 *  Gets the ECDH shared secret of our node secret and `other_key`, multiplying by `tweak` if
-	 *  one is provided. Note that this tweak can be applied to `other_key` instead of our node
-	 *  secret, though this is less efficient.
-	 * 
-	 *  Note that if this fails while attempting to forward an HTLC, LDK will panic. The error
-	 *  should be resolved to allow LDK to resume forwarding HTLCs.
-	 * 
-	 *  Errors if the [`Recipient`] variant is not supported by the implementation.
-	 */
-	inline LDK::CResult_ThirtyTwoBytesNoneZ ecdh(enum LDKRecipient recipient, struct LDKPublicKey other_key, struct LDKCOption_BigEndianScalarZ tweak);
+	inline LDK::CResult_ThirtyTwoBytesNoneZ ecdh(enum LDKRecipient recipient, struct LDKPublicKey other_key, struct LDKCOption_BigEndianScalarZ tweak);
 	/**
 	 *  Sign an invoice.
 	 * 
@@ -1155,7 +1228,7 @@ public:
 	 * 
 	 *  Errors if the [`Recipient`] variant is not supported by the implementation.
 	 */
-	inline LDK::CResult_RecoverableSignatureNoneZ sign_invoice(struct LDKu8slice hrp_bytes, struct LDKCVec_U5Z invoice_data, enum LDKRecipient recipient);
+	inline LDK::CResult_RecoverableSignatureNoneZ sign_invoice(const struct LDKRawBolt11Invoice *NONNULL_PTR invoice, enum LDKRecipient recipient);
 	/**
 	 *  Signs the [`TaggedHash`] of a BOLT 12 invoice request.
 	 * 
@@ -1194,6 +1267,36 @@ public:
 	 */
 	inline LDK::CResult_ECDSASignatureNoneZ sign_gossip_message(struct LDKUnsignedGossipMessage msg);
 };
+class OutputSpender {
+private:
+	LDKOutputSpender self;
+public:
+	OutputSpender(const OutputSpender&) = delete;
+	OutputSpender(OutputSpender&& o) : self(o.self) { memset(&o, 0, sizeof(OutputSpender)); }
+	OutputSpender(LDKOutputSpender&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOutputSpender)); }
+	operator LDKOutputSpender() && { LDKOutputSpender res = self; memset(&self, 0, sizeof(LDKOutputSpender)); return res; }
+	~OutputSpender() { OutputSpender_free(self); }
+	OutputSpender& operator=(OutputSpender&& o) { OutputSpender_free(self); self = o.self; memset(&o, 0, sizeof(OutputSpender)); return *this; }
+	LDKOutputSpender* operator &() { return &self; }
+	LDKOutputSpender* operator ->() { return &self; }
+	const LDKOutputSpender* operator &() const { return &self; }
+	const LDKOutputSpender* operator ->() const { return &self; }
+	/**
+	 *  Creates a [`Transaction`] which spends the given descriptors to the given outputs, plus an
+	 *  output to the given change destination (if sufficient change value remains). The
+	 *  transaction will have a feerate, at least, of the given value.
+	 * 
+	 *  The `locktime` argument is used to set the transaction's locktime. If `None`, the
+	 *  transaction will have a locktime of 0. It it recommended to set this to the current block
+	 *  height to avoid fee sniping, unless you have some specific reason to use a different
+	 *  locktime.
+	 * 
+	 *  Returns `Err(())` if the output value is greater than the input value minus required fee,
+	 *  if a descriptor was duplicated, or if an output descriptor `script_pubkey`
+	 *  does not match the one we can spend.
+	 */
+	inline LDK::CResult_TransactionNoneZ spend_spendable_outputs(struct LDKCVec_SpendableOutputDescriptorZ descriptors, struct LDKCVec_TxOutZ outputs, struct LDKCVec_u8Z change_destination_script, uint32_t feerate_sat_per_1000_weight, struct LDKCOption_u32Z locktime);
+};
 class SignerProvider {
 private:
 	LDKSignerProvider self;
@@ -1209,7 +1312,7 @@ public:
 	const LDKSignerProvider* operator &() const { return &self; }
 	const LDKSignerProvider* operator ->() const { return &self; }
 	/**
-	 *  Generates a unique `channel_keys_id` that can be used to obtain a [`Self::Signer`] through
+	 *  Generates a unique `channel_keys_id` that can be used to obtain a [`Self::EcdsaSigner`] through
 	 *  [`SignerProvider::derive_channel_signer`]. The `user_channel_id` is provided to allow
 	 *  implementations of [`SignerProvider`] to maintain a mapping between itself and the generated
 	 *  `channel_keys_id`.
@@ -1225,11 +1328,11 @@ public:
 	 *  re-derived from its `channel_keys_id`, which can be obtained through its trait method
 	 *  [`ChannelSigner::channel_keys_id`].
 	 */
-	inline LDK::WriteableEcdsaChannelSigner derive_channel_signer(uint64_t channel_value_satoshis, struct LDKThirtyTwoBytes channel_keys_id);
+	inline LDK::EcdsaChannelSigner derive_channel_signer(uint64_t channel_value_satoshis, struct LDKThirtyTwoBytes channel_keys_id);
 	/**
 	 *  Reads a [`Signer`] for this [`SignerProvider`] from the given input stream.
 	 *  This is only called during deserialization of other objects which contain
-	 *  [`WriteableEcdsaChannelSigner`]-implementing objects (i.e., [`ChannelMonitor`]s and [`ChannelManager`]s).
+	 *  [`EcdsaChannelSigner`]-implementing objects (i.e., [`ChannelMonitor`]s and [`ChannelManager`]s).
 	 *  The bytes are exactly those which `<Self::Signer as Writeable>::write()` writes, and
 	 *  contain no versioning scheme. You may wish to include your own version prefix and ensure
 	 *  you've read all of the provided bytes to ensure no corruption occurred.
@@ -1237,20 +1340,21 @@ public:
 	 *  This method is slowly being phased out -- it will only be called when reading objects
 	 *  written by LDK versions prior to 0.0.113.
 	 * 
-	 *  [`Signer`]: Self::Signer
+	 *  [`Signer`]: Self::EcdsaSigner
 	 *  [`ChannelMonitor`]: crate::chain::channelmonitor::ChannelMonitor
 	 *  [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
 	 */
-	inline LDK::CResult_WriteableEcdsaChannelSignerDecodeErrorZ read_chan_signer(struct LDKu8slice reader);
+	inline LDK::CResult_EcdsaChannelSignerDecodeErrorZ read_chan_signer(struct LDKu8slice reader);
 	/**
 	 *  Get a script pubkey which we send funds to when claiming on-chain contestable outputs.
 	 * 
 	 *  If this function returns an error, this will result in a channel failing to open.
 	 * 
 	 *  This method should return a different value each time it is called, to avoid linking
-	 *  on-chain funds across channels as controlled to the same user.
+	 *  on-chain funds across channels as controlled to the same user. `channel_keys_id` may be
+	 *  used to derive a unique value for each channel.
 	 */
-	inline LDK::CResult_CVec_u8ZNoneZ get_destination_script();
+	inline LDK::CResult_CVec_u8ZNoneZ get_destination_script(struct LDKThirtyTwoBytes channel_keys_id);
 	/**
 	 *  Get a script pubkey which we will send funds to when closing a channel.
 	 * 
@@ -1263,6 +1367,29 @@ public:
 	 */
 	inline LDK::CResult_ShutdownScriptNoneZ get_shutdown_scriptpubkey();
 };
+class ChangeDestinationSource {
+private:
+	LDKChangeDestinationSource self;
+public:
+	ChangeDestinationSource(const ChangeDestinationSource&) = delete;
+	ChangeDestinationSource(ChangeDestinationSource&& o) : self(o.self) { memset(&o, 0, sizeof(ChangeDestinationSource)); }
+	ChangeDestinationSource(LDKChangeDestinationSource&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChangeDestinationSource)); }
+	operator LDKChangeDestinationSource() && { LDKChangeDestinationSource res = self; memset(&self, 0, sizeof(LDKChangeDestinationSource)); return res; }
+	~ChangeDestinationSource() { ChangeDestinationSource_free(self); }
+	ChangeDestinationSource& operator=(ChangeDestinationSource&& o) { ChangeDestinationSource_free(self); self = o.self; memset(&o, 0, sizeof(ChangeDestinationSource)); return *this; }
+	LDKChangeDestinationSource* operator &() { return &self; }
+	LDKChangeDestinationSource* operator ->() { return &self; }
+	const LDKChangeDestinationSource* operator &() const { return &self; }
+	const LDKChangeDestinationSource* operator ->() const { return &self; }
+	/**
+	 *  Returns a script pubkey which can be used as a change destination for
+	 *  [`OutputSpender::spend_spendable_outputs`].
+	 * 
+	 *  This method should return a different value each time it is called, to avoid linking
+	 *  on-chain funds controlled to the same user.
+	 */
+	inline LDK::CResult_CVec_u8ZNoneZ get_change_destination_script();
+};
 class InMemorySigner {
 private:
 	LDKInMemorySigner self;
@@ -1308,6 +1435,21 @@ public:
 	const LDKPhantomKeysManager* operator &() const { return &self; }
 	const LDKPhantomKeysManager* operator ->() const { return &self; }
 };
+class RandomBytes {
+private:
+	LDKRandomBytes self;
+public:
+	RandomBytes(const RandomBytes&) = delete;
+	RandomBytes(RandomBytes&& o) : self(o.self) { memset(&o, 0, sizeof(RandomBytes)); }
+	RandomBytes(LDKRandomBytes&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRandomBytes)); }
+	operator LDKRandomBytes() && { LDKRandomBytes res = self; memset(&self, 0, sizeof(LDKRandomBytes)); return res; }
+	~RandomBytes() { RandomBytes_free(self); }
+	RandomBytes& operator=(RandomBytes&& o) { RandomBytes_free(self); self = o.self; memset(&o, 0, sizeof(RandomBytes)); return *this; }
+	LDKRandomBytes* operator &() { return &self; }
+	LDKRandomBytes* operator ->() { return &self; }
+	const LDKRandomBytes* operator &() const { return &self; }
+	const LDKRandomBytes* operator ->() const { return &self; }
+};
 class BackgroundProcessor {
 private:
 	LDKBackgroundProcessor self;
@@ -1388,6 +1530,12 @@ public:
 	 *  Note that first_hops (or a relevant inner pointer) may be NULL or all-0s to represent None
 	 */
 	inline LDK::CResult_RouteLightningErrorZ find_route_with_id(struct LDKPublicKey payer, const struct LDKRouteParameters *NONNULL_PTR route_params, struct LDKCVec_ChannelDetailsZ *first_hops, struct LDKInFlightHtlcs inflight_htlcs, struct LDKThirtyTwoBytes _payment_hash, struct LDKThirtyTwoBytes _payment_id);
+	/**
+	 *  Creates [`BlindedPaymentPath`]s for payment to the `recipient` node. The channels in `first_hops`
+	 *  are assumed to be with the `recipient`'s peers. The payment secret and any constraints are
+	 *  given in `tlvs`.
+	 */
+	inline LDK::CResult_CVec_BlindedPaymentPathZNoneZ create_blinded_payment_paths(struct LDKPublicKey recipient, struct LDKCVec_ChannelDetailsZ first_hops, struct LDKReceiveTlvs tlvs, uint64_t amount_msats);
 };
 class ScorerAccountingForInFlightHtlcs {
 private:
@@ -1524,35 +1672,125 @@ public:
 	const LDKPayee* operator &() const { return &self; }
 	const LDKPayee* operator ->() const { return &self; }
 };
-class RouteHint {
+class FirstHopCandidate {
+private:
+	LDKFirstHopCandidate self;
+public:
+	FirstHopCandidate(const FirstHopCandidate&) = delete;
+	FirstHopCandidate(FirstHopCandidate&& o) : self(o.self) { memset(&o, 0, sizeof(FirstHopCandidate)); }
+	FirstHopCandidate(LDKFirstHopCandidate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFirstHopCandidate)); }
+	operator LDKFirstHopCandidate() && { LDKFirstHopCandidate res = self; memset(&self, 0, sizeof(LDKFirstHopCandidate)); return res; }
+	~FirstHopCandidate() { FirstHopCandidate_free(self); }
+	FirstHopCandidate& operator=(FirstHopCandidate&& o) { FirstHopCandidate_free(self); self = o.self; memset(&o, 0, sizeof(FirstHopCandidate)); return *this; }
+	LDKFirstHopCandidate* operator &() { return &self; }
+	LDKFirstHopCandidate* operator ->() { return &self; }
+	const LDKFirstHopCandidate* operator &() const { return &self; }
+	const LDKFirstHopCandidate* operator ->() const { return &self; }
+};
+class PublicHopCandidate {
+private:
+	LDKPublicHopCandidate self;
+public:
+	PublicHopCandidate(const PublicHopCandidate&) = delete;
+	PublicHopCandidate(PublicHopCandidate&& o) : self(o.self) { memset(&o, 0, sizeof(PublicHopCandidate)); }
+	PublicHopCandidate(LDKPublicHopCandidate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPublicHopCandidate)); }
+	operator LDKPublicHopCandidate() && { LDKPublicHopCandidate res = self; memset(&self, 0, sizeof(LDKPublicHopCandidate)); return res; }
+	~PublicHopCandidate() { PublicHopCandidate_free(self); }
+	PublicHopCandidate& operator=(PublicHopCandidate&& o) { PublicHopCandidate_free(self); self = o.self; memset(&o, 0, sizeof(PublicHopCandidate)); return *this; }
+	LDKPublicHopCandidate* operator &() { return &self; }
+	LDKPublicHopCandidate* operator ->() { return &self; }
+	const LDKPublicHopCandidate* operator &() const { return &self; }
+	const LDKPublicHopCandidate* operator ->() const { return &self; }
+};
+class PrivateHopCandidate {
+private:
+	LDKPrivateHopCandidate self;
+public:
+	PrivateHopCandidate(const PrivateHopCandidate&) = delete;
+	PrivateHopCandidate(PrivateHopCandidate&& o) : self(o.self) { memset(&o, 0, sizeof(PrivateHopCandidate)); }
+	PrivateHopCandidate(LDKPrivateHopCandidate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPrivateHopCandidate)); }
+	operator LDKPrivateHopCandidate() && { LDKPrivateHopCandidate res = self; memset(&self, 0, sizeof(LDKPrivateHopCandidate)); return res; }
+	~PrivateHopCandidate() { PrivateHopCandidate_free(self); }
+	PrivateHopCandidate& operator=(PrivateHopCandidate&& o) { PrivateHopCandidate_free(self); self = o.self; memset(&o, 0, sizeof(PrivateHopCandidate)); return *this; }
+	LDKPrivateHopCandidate* operator &() { return &self; }
+	LDKPrivateHopCandidate* operator ->() { return &self; }
+	const LDKPrivateHopCandidate* operator &() const { return &self; }
+	const LDKPrivateHopCandidate* operator ->() const { return &self; }
+};
+class BlindedPathCandidate {
+private:
+	LDKBlindedPathCandidate self;
+public:
+	BlindedPathCandidate(const BlindedPathCandidate&) = delete;
+	BlindedPathCandidate(BlindedPathCandidate&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedPathCandidate)); }
+	BlindedPathCandidate(LDKBlindedPathCandidate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedPathCandidate)); }
+	operator LDKBlindedPathCandidate() && { LDKBlindedPathCandidate res = self; memset(&self, 0, sizeof(LDKBlindedPathCandidate)); return res; }
+	~BlindedPathCandidate() { BlindedPathCandidate_free(self); }
+	BlindedPathCandidate& operator=(BlindedPathCandidate&& o) { BlindedPathCandidate_free(self); self = o.self; memset(&o, 0, sizeof(BlindedPathCandidate)); return *this; }
+	LDKBlindedPathCandidate* operator &() { return &self; }
+	LDKBlindedPathCandidate* operator ->() { return &self; }
+	const LDKBlindedPathCandidate* operator &() const { return &self; }
+	const LDKBlindedPathCandidate* operator ->() const { return &self; }
+};
+class OneHopBlindedPathCandidate {
+private:
+	LDKOneHopBlindedPathCandidate self;
+public:
+	OneHopBlindedPathCandidate(const OneHopBlindedPathCandidate&) = delete;
+	OneHopBlindedPathCandidate(OneHopBlindedPathCandidate&& o) : self(o.self) { memset(&o, 0, sizeof(OneHopBlindedPathCandidate)); }
+	OneHopBlindedPathCandidate(LDKOneHopBlindedPathCandidate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOneHopBlindedPathCandidate)); }
+	operator LDKOneHopBlindedPathCandidate() && { LDKOneHopBlindedPathCandidate res = self; memset(&self, 0, sizeof(LDKOneHopBlindedPathCandidate)); return res; }
+	~OneHopBlindedPathCandidate() { OneHopBlindedPathCandidate_free(self); }
+	OneHopBlindedPathCandidate& operator=(OneHopBlindedPathCandidate&& o) { OneHopBlindedPathCandidate_free(self); self = o.self; memset(&o, 0, sizeof(OneHopBlindedPathCandidate)); return *this; }
+	LDKOneHopBlindedPathCandidate* operator &() { return &self; }
+	LDKOneHopBlindedPathCandidate* operator ->() { return &self; }
+	const LDKOneHopBlindedPathCandidate* operator &() const { return &self; }
+	const LDKOneHopBlindedPathCandidate* operator ->() const { return &self; }
+};
+class CandidateRouteHop {
+private:
+	LDKCandidateRouteHop self;
+public:
+	CandidateRouteHop(const CandidateRouteHop&) = delete;
+	CandidateRouteHop(CandidateRouteHop&& o) : self(o.self) { memset(&o, 0, sizeof(CandidateRouteHop)); }
+	CandidateRouteHop(LDKCandidateRouteHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCandidateRouteHop)); }
+	operator LDKCandidateRouteHop() && { LDKCandidateRouteHop res = self; memset(&self, 0, sizeof(LDKCandidateRouteHop)); return res; }
+	~CandidateRouteHop() { CandidateRouteHop_free(self); }
+	CandidateRouteHop& operator=(CandidateRouteHop&& o) { CandidateRouteHop_free(self); self = o.self; memset(&o, 0, sizeof(CandidateRouteHop)); return *this; }
+	LDKCandidateRouteHop* operator &() { return &self; }
+	LDKCandidateRouteHop* operator ->() { return &self; }
+	const LDKCandidateRouteHop* operator &() const { return &self; }
+	const LDKCandidateRouteHop* operator ->() const { return &self; }
+};
+class UntrustedString {
 private:
-	LDKRouteHint self;
+	LDKUntrustedString self;
 public:
-	RouteHint(const RouteHint&) = delete;
-	RouteHint(RouteHint&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHint)); }
-	RouteHint(LDKRouteHint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHint)); }
-	operator LDKRouteHint() && { LDKRouteHint res = self; memset(&self, 0, sizeof(LDKRouteHint)); return res; }
-	~RouteHint() { RouteHint_free(self); }
-	RouteHint& operator=(RouteHint&& o) { RouteHint_free(self); self = o.self; memset(&o, 0, sizeof(RouteHint)); return *this; }
-	LDKRouteHint* operator &() { return &self; }
-	LDKRouteHint* operator ->() { return &self; }
-	const LDKRouteHint* operator &() const { return &self; }
-	const LDKRouteHint* operator ->() const { return &self; }
+	UntrustedString(const UntrustedString&) = delete;
+	UntrustedString(UntrustedString&& o) : self(o.self) { memset(&o, 0, sizeof(UntrustedString)); }
+	UntrustedString(LDKUntrustedString&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUntrustedString)); }
+	operator LDKUntrustedString() && { LDKUntrustedString res = self; memset(&self, 0, sizeof(LDKUntrustedString)); return res; }
+	~UntrustedString() { UntrustedString_free(self); }
+	UntrustedString& operator=(UntrustedString&& o) { UntrustedString_free(self); self = o.self; memset(&o, 0, sizeof(UntrustedString)); return *this; }
+	LDKUntrustedString* operator &() { return &self; }
+	LDKUntrustedString* operator ->() { return &self; }
+	const LDKUntrustedString* operator &() const { return &self; }
+	const LDKUntrustedString* operator ->() const { return &self; }
 };
-class RouteHintHop {
+class PrintableString {
 private:
-	LDKRouteHintHop self;
+	LDKPrintableString self;
 public:
-	RouteHintHop(const RouteHintHop&) = delete;
-	RouteHintHop(RouteHintHop&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHintHop)); }
-	RouteHintHop(LDKRouteHintHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHintHop)); }
-	operator LDKRouteHintHop() && { LDKRouteHintHop res = self; memset(&self, 0, sizeof(LDKRouteHintHop)); return res; }
-	~RouteHintHop() { RouteHintHop_free(self); }
-	RouteHintHop& operator=(RouteHintHop&& o) { RouteHintHop_free(self); self = o.self; memset(&o, 0, sizeof(RouteHintHop)); return *this; }
-	LDKRouteHintHop* operator &() { return &self; }
-	LDKRouteHintHop* operator ->() { return &self; }
-	const LDKRouteHintHop* operator &() const { return &self; }
-	const LDKRouteHintHop* operator ->() const { return &self; }
+	PrintableString(const PrintableString&) = delete;
+	PrintableString(PrintableString&& o) : self(o.self) { memset(&o, 0, sizeof(PrintableString)); }
+	PrintableString(LDKPrintableString&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPrintableString)); }
+	operator LDKPrintableString() && { LDKPrintableString res = self; memset(&self, 0, sizeof(LDKPrintableString)); return res; }
+	~PrintableString() { PrintableString_free(self); }
+	PrintableString& operator=(PrintableString&& o) { PrintableString_free(self); self = o.self; memset(&o, 0, sizeof(PrintableString)); return *this; }
+	LDKPrintableString* operator &() { return &self; }
+	LDKPrintableString* operator ->() { return &self; }
+	const LDKPrintableString* operator &() const { return &self; }
+	const LDKPrintableString* operator ->() const { return &self; }
 };
 class ScoreLookUp {
 private:
@@ -1578,7 +1816,7 @@ public:
 	 *  [`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, const struct LDKNodeId *NONNULL_PTR source, const struct LDKNodeId *NONNULL_PTR target, struct LDKChannelUsage usage, const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR score_params);
+	inline uint64_t channel_penalty_msat(const struct LDKCandidateRouteHop *NONNULL_PTR candidate, struct LDKChannelUsage usage, const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR score_params);
 };
 class ScoreUpdate {
 private:
@@ -1597,19 +1835,26 @@ public:
 	/**
 	 *  Handles updating channel penalties after failing to route through a channel.
 	 */
-	inline void payment_path_failed(const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id);
+	inline void payment_path_failed(const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id, uint64_t duration_since_epoch);
 	/**
 	 *  Handles updating channel penalties after successfully routing along a path.
 	 */
-	inline void payment_path_successful(const struct LDKPath *NONNULL_PTR path);
+	inline void payment_path_successful(const struct LDKPath *NONNULL_PTR path, uint64_t duration_since_epoch);
 	/**
 	 *  Handles updating channel penalties after a probe over the given path failed.
 	 */
-	inline void probe_failed(const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id);
+	inline void probe_failed(const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id, uint64_t duration_since_epoch);
 	/**
 	 *  Handles updating channel penalties after a probe over the given path succeeded.
 	 */
-	inline void probe_successful(const struct LDKPath *NONNULL_PTR path);
+	inline void probe_successful(const struct LDKPath *NONNULL_PTR path, uint64_t duration_since_epoch);
+	/**
+	 *  Scorers may wish to reduce their certainty of channel liquidity information over time.
+	 *  Thus, this method is provided to allow scorers to observe the passage of time - the holder
+	 *  of this object should call this method regularly (generally via the
+	 *  `lightning-background-processor` crate).
+	 */
+	inline void time_passed(uint64_t duration_since_epoch);
 };
 class Score {
 private:
@@ -1878,7 +2123,7 @@ public:
 	inline void best_block_updated(const uint8_t (*header)[80], uint32_t height);
 	/**
 	 *  Returns transactions that must be monitored for reorganization out of the chain along
-	 *  with the hash of the block as part of which it had been previously confirmed.
+	 *  with the height and the hash of the block as part of which it had been previously confirmed.
 	 * 
 	 *  Note that the returned `Option<BlockHash>` might be `None` for channels created with LDK
 	 *  0.0.112 and prior, in which case you need to manually track previous confirmations.
@@ -1893,13 +2138,13 @@ public:
 	 *  given to [`transaction_unconfirmed`].
 	 * 
 	 *  If any of the returned transactions are confirmed in a block other than the one with the
-	 *  given hash, they need to be unconfirmed and reconfirmed via [`transaction_unconfirmed`] and
-	 *  [`transactions_confirmed`], respectively.
+	 *  given hash at the given height, they need to be unconfirmed and reconfirmed via
+	 *  [`transaction_unconfirmed`] and [`transactions_confirmed`], respectively.
 	 * 
 	 *  [`transactions_confirmed`]: Self::transactions_confirmed
 	 *  [`transaction_unconfirmed`]: Self::transaction_unconfirmed
 	 */
-	inline LDK::CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ get_relevant_txids();
+	inline LDK::CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ get_relevant_txids();
 };
 class ChannelMonitorUpdateStatus {
 private:
@@ -1976,7 +2221,7 @@ public:
 	 *  For details on asynchronous [`ChannelMonitor`] updating and returning
 	 *  [`MonitorEvent::Completed`] here, see [`ChannelMonitorUpdateStatus::InProgress`].
 	 */
-	inline LDK::CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ release_pending_monitor_events();
+	inline LDK::CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ release_pending_monitor_events();
 };
 class Filter {
 private:
@@ -1995,6 +2240,11 @@ public:
 	/**
 	 *  Registers interest in a transaction with `txid` and having an output with `script_pubkey` as
 	 *  a spending condition.
+	 * 
+	 *  This may be used, for example, to monitor for when a funding transaction confirms.
+	 * 
+	 *  The `script_pubkey` is provided for informational purposes and may be useful for block
+	 *  sources which only support filtering on scripts.
 	 */
 	inline void register_tx(const uint8_t (*txid)[32], struct LDKu8slice script_pubkey);
 	/**
@@ -2004,6 +2254,9 @@ public:
 	 *  to ensure that also dependent output spents within an already connected block are correctly
 	 *  handled, e.g., by re-scanning the block in question whenever new outputs have been
 	 *  registered mid-processing.
+	 * 
+	 *  This may be used, for example, to monitor for when a funding output is spent (by any
+	 *  transaction).
 	 */
 	inline void register_output(struct LDKWatchedOutput output);
 };
@@ -2022,142 +2275,52 @@ public:
 	const LDKWatchedOutput* operator &() const { return &self; }
 	const LDKWatchedOutput* operator ->() const { return &self; }
 };
-class InitFeatures {
-private:
-	LDKInitFeatures self;
-public:
-	InitFeatures(const InitFeatures&) = delete;
-	InitFeatures(InitFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(InitFeatures)); }
-	InitFeatures(LDKInitFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInitFeatures)); }
-	operator LDKInitFeatures() && { LDKInitFeatures res = self; memset(&self, 0, sizeof(LDKInitFeatures)); return res; }
-	~InitFeatures() { InitFeatures_free(self); }
-	InitFeatures& operator=(InitFeatures&& o) { InitFeatures_free(self); self = o.self; memset(&o, 0, sizeof(InitFeatures)); return *this; }
-	LDKInitFeatures* operator &() { return &self; }
-	LDKInitFeatures* operator ->() { return &self; }
-	const LDKInitFeatures* operator &() const { return &self; }
-	const LDKInitFeatures* operator ->() const { return &self; }
-};
-class NodeFeatures {
-private:
-	LDKNodeFeatures self;
-public:
-	NodeFeatures(const NodeFeatures&) = delete;
-	NodeFeatures(NodeFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(NodeFeatures)); }
-	NodeFeatures(LDKNodeFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeFeatures)); }
-	operator LDKNodeFeatures() && { LDKNodeFeatures res = self; memset(&self, 0, sizeof(LDKNodeFeatures)); return res; }
-	~NodeFeatures() { NodeFeatures_free(self); }
-	NodeFeatures& operator=(NodeFeatures&& o) { NodeFeatures_free(self); self = o.self; memset(&o, 0, sizeof(NodeFeatures)); return *this; }
-	LDKNodeFeatures* operator &() { return &self; }
-	LDKNodeFeatures* operator ->() { return &self; }
-	const LDKNodeFeatures* operator &() const { return &self; }
-	const LDKNodeFeatures* operator ->() const { return &self; }
-};
-class ChannelFeatures {
-private:
-	LDKChannelFeatures self;
-public:
-	ChannelFeatures(const ChannelFeatures&) = delete;
-	ChannelFeatures(ChannelFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelFeatures)); }
-	ChannelFeatures(LDKChannelFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelFeatures)); }
-	operator LDKChannelFeatures() && { LDKChannelFeatures res = self; memset(&self, 0, sizeof(LDKChannelFeatures)); return res; }
-	~ChannelFeatures() { ChannelFeatures_free(self); }
-	ChannelFeatures& operator=(ChannelFeatures&& o) { ChannelFeatures_free(self); self = o.self; memset(&o, 0, sizeof(ChannelFeatures)); return *this; }
-	LDKChannelFeatures* operator &() { return &self; }
-	LDKChannelFeatures* operator ->() { return &self; }
-	const LDKChannelFeatures* operator &() const { return &self; }
-	const LDKChannelFeatures* operator ->() const { return &self; }
-};
-class Bolt11InvoiceFeatures {
-private:
-	LDKBolt11InvoiceFeatures self;
-public:
-	Bolt11InvoiceFeatures(const Bolt11InvoiceFeatures&) = delete;
-	Bolt11InvoiceFeatures(Bolt11InvoiceFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt11InvoiceFeatures)); }
-	Bolt11InvoiceFeatures(LDKBolt11InvoiceFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt11InvoiceFeatures)); }
-	operator LDKBolt11InvoiceFeatures() && { LDKBolt11InvoiceFeatures res = self; memset(&self, 0, sizeof(LDKBolt11InvoiceFeatures)); return res; }
-	~Bolt11InvoiceFeatures() { Bolt11InvoiceFeatures_free(self); }
-	Bolt11InvoiceFeatures& operator=(Bolt11InvoiceFeatures&& o) { Bolt11InvoiceFeatures_free(self); self = o.self; memset(&o, 0, sizeof(Bolt11InvoiceFeatures)); return *this; }
-	LDKBolt11InvoiceFeatures* operator &() { return &self; }
-	LDKBolt11InvoiceFeatures* operator ->() { return &self; }
-	const LDKBolt11InvoiceFeatures* operator &() const { return &self; }
-	const LDKBolt11InvoiceFeatures* operator ->() const { return &self; }
-};
-class OfferFeatures {
-private:
-	LDKOfferFeatures self;
-public:
-	OfferFeatures(const OfferFeatures&) = delete;
-	OfferFeatures(OfferFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(OfferFeatures)); }
-	OfferFeatures(LDKOfferFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOfferFeatures)); }
-	operator LDKOfferFeatures() && { LDKOfferFeatures res = self; memset(&self, 0, sizeof(LDKOfferFeatures)); return res; }
-	~OfferFeatures() { OfferFeatures_free(self); }
-	OfferFeatures& operator=(OfferFeatures&& o) { OfferFeatures_free(self); self = o.self; memset(&o, 0, sizeof(OfferFeatures)); return *this; }
-	LDKOfferFeatures* operator &() { return &self; }
-	LDKOfferFeatures* operator ->() { return &self; }
-	const LDKOfferFeatures* operator &() const { return &self; }
-	const LDKOfferFeatures* operator ->() const { return &self; }
-};
-class InvoiceRequestFeatures {
-private:
-	LDKInvoiceRequestFeatures self;
-public:
-	InvoiceRequestFeatures(const InvoiceRequestFeatures&) = delete;
-	InvoiceRequestFeatures(InvoiceRequestFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceRequestFeatures)); }
-	InvoiceRequestFeatures(LDKInvoiceRequestFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceRequestFeatures)); }
-	operator LDKInvoiceRequestFeatures() && { LDKInvoiceRequestFeatures res = self; memset(&self, 0, sizeof(LDKInvoiceRequestFeatures)); return res; }
-	~InvoiceRequestFeatures() { InvoiceRequestFeatures_free(self); }
-	InvoiceRequestFeatures& operator=(InvoiceRequestFeatures&& o) { InvoiceRequestFeatures_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceRequestFeatures)); return *this; }
-	LDKInvoiceRequestFeatures* operator &() { return &self; }
-	LDKInvoiceRequestFeatures* operator ->() { return &self; }
-	const LDKInvoiceRequestFeatures* operator &() const { return &self; }
-	const LDKInvoiceRequestFeatures* operator ->() const { return &self; }
-};
-class Bolt12InvoiceFeatures {
-private:
-	LDKBolt12InvoiceFeatures self;
-public:
-	Bolt12InvoiceFeatures(const Bolt12InvoiceFeatures&) = delete;
-	Bolt12InvoiceFeatures(Bolt12InvoiceFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt12InvoiceFeatures)); }
-	Bolt12InvoiceFeatures(LDKBolt12InvoiceFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt12InvoiceFeatures)); }
-	operator LDKBolt12InvoiceFeatures() && { LDKBolt12InvoiceFeatures res = self; memset(&self, 0, sizeof(LDKBolt12InvoiceFeatures)); return res; }
-	~Bolt12InvoiceFeatures() { Bolt12InvoiceFeatures_free(self); }
-	Bolt12InvoiceFeatures& operator=(Bolt12InvoiceFeatures&& o) { Bolt12InvoiceFeatures_free(self); self = o.self; memset(&o, 0, sizeof(Bolt12InvoiceFeatures)); return *this; }
-	LDKBolt12InvoiceFeatures* operator &() { return &self; }
-	LDKBolt12InvoiceFeatures* operator ->() { return &self; }
-	const LDKBolt12InvoiceFeatures* operator &() const { return &self; }
-	const LDKBolt12InvoiceFeatures* operator ->() const { return &self; }
-};
-class BlindedHopFeatures {
-private:
-	LDKBlindedHopFeatures self;
-public:
-	BlindedHopFeatures(const BlindedHopFeatures&) = delete;
-	BlindedHopFeatures(BlindedHopFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedHopFeatures)); }
-	BlindedHopFeatures(LDKBlindedHopFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedHopFeatures)); }
-	operator LDKBlindedHopFeatures() && { LDKBlindedHopFeatures res = self; memset(&self, 0, sizeof(LDKBlindedHopFeatures)); return res; }
-	~BlindedHopFeatures() { BlindedHopFeatures_free(self); }
-	BlindedHopFeatures& operator=(BlindedHopFeatures&& o) { BlindedHopFeatures_free(self); self = o.self; memset(&o, 0, sizeof(BlindedHopFeatures)); return *this; }
-	LDKBlindedHopFeatures* operator &() { return &self; }
-	LDKBlindedHopFeatures* operator ->() { return &self; }
-	const LDKBlindedHopFeatures* operator &() const { return &self; }
-	const LDKBlindedHopFeatures* operator ->() const { return &self; }
-};
-class ChannelTypeFeatures {
-private:
-	LDKChannelTypeFeatures self;
-public:
-	ChannelTypeFeatures(const ChannelTypeFeatures&) = delete;
-	ChannelTypeFeatures(ChannelTypeFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelTypeFeatures)); }
-	ChannelTypeFeatures(LDKChannelTypeFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelTypeFeatures)); }
-	operator LDKChannelTypeFeatures() && { LDKChannelTypeFeatures res = self; memset(&self, 0, sizeof(LDKChannelTypeFeatures)); return res; }
-	~ChannelTypeFeatures() { ChannelTypeFeatures_free(self); }
-	ChannelTypeFeatures& operator=(ChannelTypeFeatures&& o) { ChannelTypeFeatures_free(self); self = o.self; memset(&o, 0, sizeof(ChannelTypeFeatures)); return *this; }
-	LDKChannelTypeFeatures* operator &() { return &self; }
-	LDKChannelTypeFeatures* operator ->() { return &self; }
-	const LDKChannelTypeFeatures* operator &() const { return &self; }
-	const LDKChannelTypeFeatures* operator ->() const { return &self; }
-};
-class Offer {
+class OfferId {
+private:
+	LDKOfferId self;
+public:
+	OfferId(const OfferId&) = delete;
+	OfferId(OfferId&& o) : self(o.self) { memset(&o, 0, sizeof(OfferId)); }
+	OfferId(LDKOfferId&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOfferId)); }
+	operator LDKOfferId() && { LDKOfferId res = self; memset(&self, 0, sizeof(LDKOfferId)); return res; }
+	~OfferId() { OfferId_free(self); }
+	OfferId& operator=(OfferId&& o) { OfferId_free(self); self = o.self; memset(&o, 0, sizeof(OfferId)); return *this; }
+	LDKOfferId* operator &() { return &self; }
+	LDKOfferId* operator ->() { return &self; }
+	const LDKOfferId* operator &() const { return &self; }
+	const LDKOfferId* operator ->() const { return &self; }
+};
+class OfferWithExplicitMetadataBuilder {
+private:
+	LDKOfferWithExplicitMetadataBuilder self;
+public:
+	OfferWithExplicitMetadataBuilder(const OfferWithExplicitMetadataBuilder&) = delete;
+	OfferWithExplicitMetadataBuilder(OfferWithExplicitMetadataBuilder&& o) : self(o.self) { memset(&o, 0, sizeof(OfferWithExplicitMetadataBuilder)); }
+	OfferWithExplicitMetadataBuilder(LDKOfferWithExplicitMetadataBuilder&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOfferWithExplicitMetadataBuilder)); }
+	operator LDKOfferWithExplicitMetadataBuilder() && { LDKOfferWithExplicitMetadataBuilder res = self; memset(&self, 0, sizeof(LDKOfferWithExplicitMetadataBuilder)); return res; }
+	~OfferWithExplicitMetadataBuilder() { OfferWithExplicitMetadataBuilder_free(self); }
+	OfferWithExplicitMetadataBuilder& operator=(OfferWithExplicitMetadataBuilder&& o) { OfferWithExplicitMetadataBuilder_free(self); self = o.self; memset(&o, 0, sizeof(OfferWithExplicitMetadataBuilder)); return *this; }
+	LDKOfferWithExplicitMetadataBuilder* operator &() { return &self; }
+	LDKOfferWithExplicitMetadataBuilder* operator ->() { return &self; }
+	const LDKOfferWithExplicitMetadataBuilder* operator &() const { return &self; }
+	const LDKOfferWithExplicitMetadataBuilder* operator ->() const { return &self; }
+};
+class OfferWithDerivedMetadataBuilder {
+private:
+	LDKOfferWithDerivedMetadataBuilder self;
+public:
+	OfferWithDerivedMetadataBuilder(const OfferWithDerivedMetadataBuilder&) = delete;
+	OfferWithDerivedMetadataBuilder(OfferWithDerivedMetadataBuilder&& o) : self(o.self) { memset(&o, 0, sizeof(OfferWithDerivedMetadataBuilder)); }
+	OfferWithDerivedMetadataBuilder(LDKOfferWithDerivedMetadataBuilder&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOfferWithDerivedMetadataBuilder)); }
+	operator LDKOfferWithDerivedMetadataBuilder() && { LDKOfferWithDerivedMetadataBuilder res = self; memset(&self, 0, sizeof(LDKOfferWithDerivedMetadataBuilder)); return res; }
+	~OfferWithDerivedMetadataBuilder() { OfferWithDerivedMetadataBuilder_free(self); }
+	OfferWithDerivedMetadataBuilder& operator=(OfferWithDerivedMetadataBuilder&& o) { OfferWithDerivedMetadataBuilder_free(self); self = o.self; memset(&o, 0, sizeof(OfferWithDerivedMetadataBuilder)); return *this; }
+	LDKOfferWithDerivedMetadataBuilder* operator &() { return &self; }
+	LDKOfferWithDerivedMetadataBuilder* operator ->() { return &self; }
+	const LDKOfferWithDerivedMetadataBuilder* operator &() const { return &self; }
+	const LDKOfferWithDerivedMetadataBuilder* operator ->() const { return &self; }
+};
+class Offer {
 private:
 	LDKOffer self;
 public:
@@ -2337,20 +2500,20 @@ public:
 	const LDKEffectiveCapacity* operator &() const { return &self; }
 	const LDKEffectiveCapacity* operator ->() const { return &self; }
 };
-class RoutingFees {
+class NodeAnnouncementDetails {
 private:
-	LDKRoutingFees self;
+	LDKNodeAnnouncementDetails self;
 public:
-	RoutingFees(const RoutingFees&) = delete;
-	RoutingFees(RoutingFees&& o) : self(o.self) { memset(&o, 0, sizeof(RoutingFees)); }
-	RoutingFees(LDKRoutingFees&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoutingFees)); }
-	operator LDKRoutingFees() && { LDKRoutingFees res = self; memset(&self, 0, sizeof(LDKRoutingFees)); return res; }
-	~RoutingFees() { RoutingFees_free(self); }
-	RoutingFees& operator=(RoutingFees&& o) { RoutingFees_free(self); self = o.self; memset(&o, 0, sizeof(RoutingFees)); return *this; }
-	LDKRoutingFees* operator &() { return &self; }
-	LDKRoutingFees* operator ->() { return &self; }
-	const LDKRoutingFees* operator &() const { return &self; }
-	const LDKRoutingFees* operator ->() const { return &self; }
+	NodeAnnouncementDetails(const NodeAnnouncementDetails&) = delete;
+	NodeAnnouncementDetails(NodeAnnouncementDetails&& o) : self(o.self) { memset(&o, 0, sizeof(NodeAnnouncementDetails)); }
+	NodeAnnouncementDetails(LDKNodeAnnouncementDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeAnnouncementDetails)); }
+	operator LDKNodeAnnouncementDetails() && { LDKNodeAnnouncementDetails res = self; memset(&self, 0, sizeof(LDKNodeAnnouncementDetails)); return res; }
+	~NodeAnnouncementDetails() { NodeAnnouncementDetails_free(self); }
+	NodeAnnouncementDetails& operator=(NodeAnnouncementDetails&& o) { NodeAnnouncementDetails_free(self); self = o.self; memset(&o, 0, sizeof(NodeAnnouncementDetails)); return *this; }
+	LDKNodeAnnouncementDetails* operator &() { return &self; }
+	LDKNodeAnnouncementDetails* operator ->() { return &self; }
+	const LDKNodeAnnouncementDetails* operator &() const { return &self; }
+	const LDKNodeAnnouncementDetails* operator ->() const { return &self; }
 };
 class NodeAnnouncementInfo {
 private:
@@ -2397,6 +2560,35 @@ public:
 	const LDKNodeInfo* operator &() const { return &self; }
 	const LDKNodeInfo* operator ->() const { return &self; }
 };
+class ShortChannelIdError {
+private:
+	LDKShortChannelIdError self;
+public:
+	ShortChannelIdError(const ShortChannelIdError&) = delete;
+	ShortChannelIdError(ShortChannelIdError&& o) : self(o.self) { memset(&o, 0, sizeof(ShortChannelIdError)); }
+	ShortChannelIdError(LDKShortChannelIdError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKShortChannelIdError)); }
+	operator LDKShortChannelIdError() && { LDKShortChannelIdError res = self; memset(&self, 0, sizeof(LDKShortChannelIdError)); return res; }
+	ShortChannelIdError& operator=(ShortChannelIdError&& o) { self = o.self; memset(&o, 0, sizeof(ShortChannelIdError)); return *this; }
+	LDKShortChannelIdError* operator &() { return &self; }
+	LDKShortChannelIdError* operator ->() { return &self; }
+	const LDKShortChannelIdError* operator &() const { return &self; }
+	const LDKShortChannelIdError* operator ->() const { return &self; }
+};
+class InboundHTLCErr {
+private:
+	LDKInboundHTLCErr self;
+public:
+	InboundHTLCErr(const InboundHTLCErr&) = delete;
+	InboundHTLCErr(InboundHTLCErr&& o) : self(o.self) { memset(&o, 0, sizeof(InboundHTLCErr)); }
+	InboundHTLCErr(LDKInboundHTLCErr&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInboundHTLCErr)); }
+	operator LDKInboundHTLCErr() && { LDKInboundHTLCErr res = self; memset(&self, 0, sizeof(LDKInboundHTLCErr)); return res; }
+	~InboundHTLCErr() { InboundHTLCErr_free(self); }
+	InboundHTLCErr& operator=(InboundHTLCErr&& o) { InboundHTLCErr_free(self); self = o.self; memset(&o, 0, sizeof(InboundHTLCErr)); return *this; }
+	LDKInboundHTLCErr* operator &() { return &self; }
+	LDKInboundHTLCErr* operator ->() { return &self; }
+	const LDKInboundHTLCErr* operator &() const { return &self; }
+	const LDKInboundHTLCErr* operator ->() const { return &self; }
+};
 class AnchorDescriptor {
 private:
 	LDKAnchorDescriptor self;
@@ -2518,8 +2710,11 @@ public:
 	/**
 	 *  Signs and provides the full witness for all inputs within the transaction known to the
 	 *  trait (i.e., any provided via [`CoinSelectionSource::select_confirmed_utxos`]).
+	 * 
+	 *  If your wallet does not support signing PSBTs you can call `psbt.extract_tx()` to get the
+	 *  unsigned transaction and then sign it with your wallet.
 	 */
-	inline LDK::CResult_TransactionNoneZ sign_tx(struct LDKTransaction tx);
+	inline LDK::CResult_TransactionNoneZ sign_psbt(struct LDKCVec_u8Z psbt);
 };
 class WalletSource {
 private:
@@ -2548,8 +2743,11 @@ public:
 	 *  Signs and provides the full [`TxIn::script_sig`] and [`TxIn::witness`] for all inputs within
 	 *  the transaction known to the wallet (i.e., any provided via
 	 *  [`WalletSource::list_confirmed_utxos`]).
+	 * 
+	 *  If your wallet does not support signing PSBTs you can call `psbt.extract_tx()` to get the
+	 *  unsigned transaction and then sign it with your wallet.
 	 */
-	inline LDK::CResult_TransactionNoneZ sign_tx(struct LDKTransaction tx);
+	inline LDK::CResult_TransactionNoneZ sign_psbt(struct LDKCVec_u8Z psbt);
 };
 class Wallet {
 private:
@@ -2581,6 +2779,65 @@ public:
 	const LDKBumpTransactionEventHandler* operator &() const { return &self; }
 	const LDKBumpTransactionEventHandler* operator ->() const { return &self; }
 };
+class PendingHTLCRouting {
+private:
+	LDKPendingHTLCRouting self;
+public:
+	PendingHTLCRouting(const PendingHTLCRouting&) = delete;
+	PendingHTLCRouting(PendingHTLCRouting&& o) : self(o.self) { memset(&o, 0, sizeof(PendingHTLCRouting)); }
+	PendingHTLCRouting(LDKPendingHTLCRouting&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPendingHTLCRouting)); }
+	operator LDKPendingHTLCRouting() && { LDKPendingHTLCRouting res = self; memset(&self, 0, sizeof(LDKPendingHTLCRouting)); return res; }
+	~PendingHTLCRouting() { PendingHTLCRouting_free(self); }
+	PendingHTLCRouting& operator=(PendingHTLCRouting&& o) { PendingHTLCRouting_free(self); self = o.self; memset(&o, 0, sizeof(PendingHTLCRouting)); return *this; }
+	LDKPendingHTLCRouting* operator &() { return &self; }
+	LDKPendingHTLCRouting* operator ->() { return &self; }
+	const LDKPendingHTLCRouting* operator &() const { return &self; }
+	const LDKPendingHTLCRouting* operator ->() const { return &self; }
+};
+class BlindedForward {
+private:
+	LDKBlindedForward self;
+public:
+	BlindedForward(const BlindedForward&) = delete;
+	BlindedForward(BlindedForward&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedForward)); }
+	BlindedForward(LDKBlindedForward&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedForward)); }
+	operator LDKBlindedForward() && { LDKBlindedForward res = self; memset(&self, 0, sizeof(LDKBlindedForward)); return res; }
+	~BlindedForward() { BlindedForward_free(self); }
+	BlindedForward& operator=(BlindedForward&& o) { BlindedForward_free(self); self = o.self; memset(&o, 0, sizeof(BlindedForward)); return *this; }
+	LDKBlindedForward* operator &() { return &self; }
+	LDKBlindedForward* operator ->() { return &self; }
+	const LDKBlindedForward* operator &() const { return &self; }
+	const LDKBlindedForward* operator ->() const { return &self; }
+};
+class PendingHTLCInfo {
+private:
+	LDKPendingHTLCInfo self;
+public:
+	PendingHTLCInfo(const PendingHTLCInfo&) = delete;
+	PendingHTLCInfo(PendingHTLCInfo&& o) : self(o.self) { memset(&o, 0, sizeof(PendingHTLCInfo)); }
+	PendingHTLCInfo(LDKPendingHTLCInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPendingHTLCInfo)); }
+	operator LDKPendingHTLCInfo() && { LDKPendingHTLCInfo res = self; memset(&self, 0, sizeof(LDKPendingHTLCInfo)); return res; }
+	~PendingHTLCInfo() { PendingHTLCInfo_free(self); }
+	PendingHTLCInfo& operator=(PendingHTLCInfo&& o) { PendingHTLCInfo_free(self); self = o.self; memset(&o, 0, sizeof(PendingHTLCInfo)); return *this; }
+	LDKPendingHTLCInfo* operator &() { return &self; }
+	LDKPendingHTLCInfo* operator ->() { return &self; }
+	const LDKPendingHTLCInfo* operator &() const { return &self; }
+	const LDKPendingHTLCInfo* operator ->() const { return &self; }
+};
+class BlindedFailure {
+private:
+	LDKBlindedFailure self;
+public:
+	BlindedFailure(const BlindedFailure&) = delete;
+	BlindedFailure(BlindedFailure&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedFailure)); }
+	BlindedFailure(LDKBlindedFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedFailure)); }
+	operator LDKBlindedFailure() && { LDKBlindedFailure res = self; memset(&self, 0, sizeof(LDKBlindedFailure)); return res; }
+	BlindedFailure& operator=(BlindedFailure&& o) { self = o.self; memset(&o, 0, sizeof(BlindedFailure)); return *this; }
+	LDKBlindedFailure* operator &() { return &self; }
+	LDKBlindedFailure* operator ->() { return &self; }
+	const LDKBlindedFailure* operator &() const { return &self; }
+	const LDKBlindedFailure* operator ->() const { return &self; }
+};
 class FailureCode {
 private:
 	LDKFailureCode self;
@@ -2626,65 +2883,6 @@ public:
 	const LDKChainParameters* operator &() const { return &self; }
 	const LDKChainParameters* operator ->() const { return &self; }
 };
-class CounterpartyForwardingInfo {
-private:
-	LDKCounterpartyForwardingInfo self;
-public:
-	CounterpartyForwardingInfo(const CounterpartyForwardingInfo&) = delete;
-	CounterpartyForwardingInfo(CounterpartyForwardingInfo&& o) : self(o.self) { memset(&o, 0, sizeof(CounterpartyForwardingInfo)); }
-	CounterpartyForwardingInfo(LDKCounterpartyForwardingInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCounterpartyForwardingInfo)); }
-	operator LDKCounterpartyForwardingInfo() && { LDKCounterpartyForwardingInfo res = self; memset(&self, 0, sizeof(LDKCounterpartyForwardingInfo)); return res; }
-	~CounterpartyForwardingInfo() { CounterpartyForwardingInfo_free(self); }
-	CounterpartyForwardingInfo& operator=(CounterpartyForwardingInfo&& o) { CounterpartyForwardingInfo_free(self); self = o.self; memset(&o, 0, sizeof(CounterpartyForwardingInfo)); return *this; }
-	LDKCounterpartyForwardingInfo* operator &() { return &self; }
-	LDKCounterpartyForwardingInfo* operator ->() { return &self; }
-	const LDKCounterpartyForwardingInfo* operator &() const { return &self; }
-	const LDKCounterpartyForwardingInfo* operator ->() const { return &self; }
-};
-class ChannelCounterparty {
-private:
-	LDKChannelCounterparty self;
-public:
-	ChannelCounterparty(const ChannelCounterparty&) = delete;
-	ChannelCounterparty(ChannelCounterparty&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelCounterparty)); }
-	ChannelCounterparty(LDKChannelCounterparty&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelCounterparty)); }
-	operator LDKChannelCounterparty() && { LDKChannelCounterparty res = self; memset(&self, 0, sizeof(LDKChannelCounterparty)); return res; }
-	~ChannelCounterparty() { ChannelCounterparty_free(self); }
-	ChannelCounterparty& operator=(ChannelCounterparty&& o) { ChannelCounterparty_free(self); self = o.self; memset(&o, 0, sizeof(ChannelCounterparty)); return *this; }
-	LDKChannelCounterparty* operator &() { return &self; }
-	LDKChannelCounterparty* operator ->() { return &self; }
-	const LDKChannelCounterparty* operator &() const { return &self; }
-	const LDKChannelCounterparty* operator ->() const { return &self; }
-};
-class ChannelDetails {
-private:
-	LDKChannelDetails self;
-public:
-	ChannelDetails(const ChannelDetails&) = delete;
-	ChannelDetails(ChannelDetails&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelDetails)); }
-	ChannelDetails(LDKChannelDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelDetails)); }
-	operator LDKChannelDetails() && { LDKChannelDetails res = self; memset(&self, 0, sizeof(LDKChannelDetails)); return res; }
-	~ChannelDetails() { ChannelDetails_free(self); }
-	ChannelDetails& operator=(ChannelDetails&& o) { ChannelDetails_free(self); self = o.self; memset(&o, 0, sizeof(ChannelDetails)); return *this; }
-	LDKChannelDetails* operator &() { return &self; }
-	LDKChannelDetails* operator ->() { return &self; }
-	const LDKChannelDetails* operator &() const { return &self; }
-	const LDKChannelDetails* operator ->() const { return &self; }
-};
-class ChannelShutdownState {
-private:
-	LDKChannelShutdownState self;
-public:
-	ChannelShutdownState(const ChannelShutdownState&) = delete;
-	ChannelShutdownState(ChannelShutdownState&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelShutdownState)); }
-	ChannelShutdownState(LDKChannelShutdownState&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelShutdownState)); }
-	operator LDKChannelShutdownState() && { LDKChannelShutdownState res = self; memset(&self, 0, sizeof(LDKChannelShutdownState)); return res; }
-	ChannelShutdownState& operator=(ChannelShutdownState&& o) { self = o.self; memset(&o, 0, sizeof(ChannelShutdownState)); return *this; }
-	LDKChannelShutdownState* operator &() { return &self; }
-	LDKChannelShutdownState* operator ->() { return &self; }
-	const LDKChannelShutdownState* operator &() const { return &self; }
-	const LDKChannelShutdownState* operator ->() const { return &self; }
-};
 class RecentPaymentDetails {
 private:
 	LDKRecentPaymentDetails self;
@@ -2850,51 +3048,262 @@ public:
 	const LDKTaggedHash* operator &() const { return &self; }
 	const LDKTaggedHash* operator ->() const { return &self; }
 };
-class ChannelMonitorUpdate {
-private:
-	LDKChannelMonitorUpdate self;
-public:
-	ChannelMonitorUpdate(const ChannelMonitorUpdate&) = delete;
-	ChannelMonitorUpdate(ChannelMonitorUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitorUpdate)); }
-	ChannelMonitorUpdate(LDKChannelMonitorUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitorUpdate)); }
-	operator LDKChannelMonitorUpdate() && { LDKChannelMonitorUpdate res = self; memset(&self, 0, sizeof(LDKChannelMonitorUpdate)); return res; }
-	~ChannelMonitorUpdate() { ChannelMonitorUpdate_free(self); }
-	ChannelMonitorUpdate& operator=(ChannelMonitorUpdate&& o) { ChannelMonitorUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMonitorUpdate)); return *this; }
-	LDKChannelMonitorUpdate* operator &() { return &self; }
-	LDKChannelMonitorUpdate* operator ->() { return &self; }
-	const LDKChannelMonitorUpdate* operator &() const { return &self; }
-	const LDKChannelMonitorUpdate* operator ->() const { return &self; }
-};
-class MonitorEvent {
+class SignError {
 private:
-	LDKMonitorEvent self;
+	LDKSignError self;
 public:
-	MonitorEvent(const MonitorEvent&) = delete;
-	MonitorEvent(MonitorEvent&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorEvent)); }
-	MonitorEvent(LDKMonitorEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorEvent)); }
-	operator LDKMonitorEvent() && { LDKMonitorEvent res = self; memset(&self, 0, sizeof(LDKMonitorEvent)); return res; }
-	~MonitorEvent() { MonitorEvent_free(self); }
-	MonitorEvent& operator=(MonitorEvent&& o) { MonitorEvent_free(self); self = o.self; memset(&o, 0, sizeof(MonitorEvent)); return *this; }
-	LDKMonitorEvent* operator &() { return &self; }
-	LDKMonitorEvent* operator ->() { return &self; }
-	const LDKMonitorEvent* operator &() const { return &self; }
-	const LDKMonitorEvent* operator ->() const { return &self; }
+	SignError(const SignError&) = delete;
+	SignError(SignError&& o) : self(o.self) { memset(&o, 0, sizeof(SignError)); }
+	SignError(LDKSignError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignError)); }
+	operator LDKSignError() && { LDKSignError res = self; memset(&self, 0, sizeof(LDKSignError)); return res; }
+	~SignError() { SignError_free(self); }
+	SignError& operator=(SignError&& o) { SignError_free(self); self = o.self; memset(&o, 0, sizeof(SignError)); return *this; }
+	LDKSignError* operator &() { return &self; }
+	LDKSignError* operator ->() { return &self; }
+	const LDKSignError* operator &() const { return &self; }
+	const LDKSignError* operator ->() const { return &self; }
 };
-class HTLCUpdate {
+class EcdsaChannelSigner {
 private:
-	LDKHTLCUpdate self;
+	LDKEcdsaChannelSigner self;
 public:
-	HTLCUpdate(const HTLCUpdate&) = delete;
-	HTLCUpdate(HTLCUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCUpdate)); }
-	HTLCUpdate(LDKHTLCUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCUpdate)); }
-	operator LDKHTLCUpdate() && { LDKHTLCUpdate res = self; memset(&self, 0, sizeof(LDKHTLCUpdate)); return res; }
-	~HTLCUpdate() { HTLCUpdate_free(self); }
-	HTLCUpdate& operator=(HTLCUpdate&& o) { HTLCUpdate_free(self); self = o.self; memset(&o, 0, sizeof(HTLCUpdate)); return *this; }
-	LDKHTLCUpdate* operator &() { return &self; }
-	LDKHTLCUpdate* operator ->() { return &self; }
-	const LDKHTLCUpdate* operator &() const { return &self; }
-	const LDKHTLCUpdate* operator ->() const { return &self; }
-};
+	EcdsaChannelSigner(const EcdsaChannelSigner&) = delete;
+	EcdsaChannelSigner(EcdsaChannelSigner&& o) : self(o.self) { memset(&o, 0, sizeof(EcdsaChannelSigner)); }
+	EcdsaChannelSigner(LDKEcdsaChannelSigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEcdsaChannelSigner)); }
+	operator LDKEcdsaChannelSigner() && { LDKEcdsaChannelSigner res = self; memset(&self, 0, sizeof(LDKEcdsaChannelSigner)); return res; }
+	~EcdsaChannelSigner() { EcdsaChannelSigner_free(self); }
+	EcdsaChannelSigner& operator=(EcdsaChannelSigner&& o) { EcdsaChannelSigner_free(self); self = o.self; memset(&o, 0, sizeof(EcdsaChannelSigner)); return *this; }
+	LDKEcdsaChannelSigner* operator &() { return &self; }
+	LDKEcdsaChannelSigner* operator ->() { return &self; }
+	const LDKEcdsaChannelSigner* operator &() const { return &self; }
+	const LDKEcdsaChannelSigner* operator ->() const { return &self; }
+	/**
+	 *  Create a signature for a counterparty's commitment transaction and associated HTLC transactions.
+	 * 
+	 *  Note that if signing fails or is rejected, the channel will be force-closed.
+	 * 
+	 *  Policy checks should be implemented in this function, including checking the amount
+	 *  sent to us and checking the HTLCs.
+	 * 
+	 *  The preimages of outbound and inbound HTLCs that were fulfilled since the last commitment
+	 *  are provided. A validating signer should ensure that an outbound HTLC output is removed
+	 *  only when the matching preimage is provided and after the corresponding inbound HTLC has
+	 *  been removed for forwarded payments.
+	 * 
+	 *  Note that all the relevant preimages will be provided, but there may also be additional
+	 *  irrelevant or duplicate preimages.
+	 */
+	inline LDK::CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ sign_counterparty_commitment(const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx, struct LDKCVec_ThirtyTwoBytesZ inbound_htlc_preimages, struct LDKCVec_ThirtyTwoBytesZ outbound_htlc_preimages);
+	/**
+	 *  Creates a signature for a holder's commitment transaction.
+	 * 
+	 *  This will be called
+	 *  - with a non-revoked `commitment_tx`.
+	 *  - with the latest `commitment_tx` when we initiate a force-close.
+	 * 
+	 *  This may be called multiple times for the same transaction.
+	 * 
+	 *  An external signer implementation should check that the commitment has not been revoked.
+	 * 
+	 *  An `Err` can be returned to signal that the signer is unavailable/cannot produce a valid
+	 *  signature and should be retried later. Once the signer is ready to provide a signature after
+	 *  previously returning an `Err`, [`ChannelMonitor::signer_unblocked`] must be called on its
+	 *  monitor.
+	 * 
+	 *  [`ChannelMonitor::signer_unblocked`]: crate::chain::channelmonitor::ChannelMonitor::signer_unblocked
+	 */
+	inline LDK::CResult_ECDSASignatureNoneZ sign_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx);
+	/**
+	 *  Create a signature for the given input in a transaction spending an HTLC transaction output
+	 *  or a commitment transaction `to_local` output when our counterparty broadcasts an old state.
+	 * 
+	 *  A justice transaction may claim multiple outputs at the same time if timelocks are
+	 *  similar, but only a signature for the input at index `input` should be signed for here.
+	 *  It may be called multiple times for same output(s) if a fee-bump is needed with regards
+	 *  to an upcoming timelock expiration.
+	 * 
+	 *  Amount is value of the output spent by this input, committed to in the BIP 143 signature.
+	 * 
+	 *  `per_commitment_key` is revocation secret which was provided by our counterparty when they
+	 *  revoked the state which they eventually broadcast. It's not a _holder_ secret key and does
+	 *  not allow the spending of any funds by itself (you need our holder `revocation_secret` to do
+	 *  so).
+	 * 
+	 *  An `Err` can be returned to signal that the signer is unavailable/cannot produce a valid
+	 *  signature and should be retried later. Once the signer is ready to provide a signature after
+	 *  previously returning an `Err`, [`ChannelMonitor::signer_unblocked`] must be called on its
+	 *  monitor.
+	 * 
+	 *  [`ChannelMonitor::signer_unblocked`]: crate::chain::channelmonitor::ChannelMonitor::signer_unblocked
+	 */
+	inline LDK::CResult_ECDSASignatureNoneZ sign_justice_revoked_output(struct LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (*per_commitment_key)[32]);
+	/**
+	 *  Create a signature for the given input in a transaction spending a commitment transaction
+	 *  HTLC output when our counterparty broadcasts an old state.
+	 * 
+	 *  A justice transaction may claim multiple outputs at the same time if timelocks are
+	 *  similar, but only a signature for the input at index `input` should be signed for here.
+	 *  It may be called multiple times for same output(s) if a fee-bump is needed with regards
+	 *  to an upcoming timelock expiration.
+	 * 
+	 *  `amount` is the value of the output spent by this input, committed to in the BIP 143
+	 *  signature.
+	 * 
+	 *  `per_commitment_key` is revocation secret which was provided by our counterparty when they
+	 *  revoked the state which they eventually broadcast. It's not a _holder_ secret key and does
+	 *  not allow the spending of any funds by itself (you need our holder revocation_secret to do
+	 *  so).
+	 * 
+	 *  `htlc` holds HTLC elements (hash, timelock), thus changing the format of the witness script
+	 *  (which is committed to in the BIP 143 signatures).
+	 * 
+	 *  An `Err` can be returned to signal that the signer is unavailable/cannot produce a valid
+	 *  signature and should be retried later. Once the signer is ready to provide a signature after
+	 *  previously returning an `Err`, [`ChannelMonitor::signer_unblocked`] must be called on its
+	 *  monitor.
+	 * 
+	 *  [`ChannelMonitor::signer_unblocked`]: crate::chain::channelmonitor::ChannelMonitor::signer_unblocked
+	 */
+	inline LDK::CResult_ECDSASignatureNoneZ sign_justice_revoked_htlc(struct LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (*per_commitment_key)[32], const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc);
+	/**
+	 *  Computes the signature for a commitment transaction's HTLC output used as an input within
+	 *  `htlc_tx`, which spends the commitment transaction at index `input`. The signature returned
+	 *  must be be computed using [`EcdsaSighashType::All`].
+	 * 
+	 *  Note that this may be called for HTLCs in the penultimate commitment transaction if a
+	 *  [`ChannelMonitor`] [replica](https://github.com/lightningdevkit/rust-lightning/blob/main/GLOSSARY.md#monitor-replicas)
+	 *  broadcasts it before receiving the update for the latest commitment transaction.
+	 * 
+	 *  An `Err` can be returned to signal that the signer is unavailable/cannot produce a valid
+	 *  signature and should be retried later. Once the signer is ready to provide a signature after
+	 *  previously returning an `Err`, [`ChannelMonitor::signer_unblocked`] must be called on its
+	 *  monitor.
+	 * 
+	 *  [`EcdsaSighashType::All`]: bitcoin::sighash::EcdsaSighashType::All
+	 *  [`ChannelMonitor`]: crate::chain::channelmonitor::ChannelMonitor
+	 *  [`ChannelMonitor::signer_unblocked`]: crate::chain::channelmonitor::ChannelMonitor::signer_unblocked
+	 */
+	inline LDK::CResult_ECDSASignatureNoneZ sign_holder_htlc_transaction(struct LDKTransaction htlc_tx, uintptr_t input, const struct LDKHTLCDescriptor *NONNULL_PTR htlc_descriptor);
+	/**
+	 *  Create a signature for a claiming transaction for a HTLC output on a counterparty's commitment
+	 *  transaction, either offered or received.
+	 * 
+	 *  Such a transaction may claim multiples offered outputs at same time if we know the
+	 *  preimage for each when we create it, but only the input at index `input` should be
+	 *  signed for here. It may be called multiple times for same output(s) if a fee-bump is
+	 *  needed with regards to an upcoming timelock expiration.
+	 * 
+	 *  `witness_script` is either an offered or received script as defined in BOLT3 for HTLC
+	 *  outputs.
+	 * 
+	 *  `amount` is value of the output spent by this input, committed to in the BIP 143 signature.
+	 * 
+	 *  `per_commitment_point` is the dynamic point corresponding to the channel state
+	 *  detected onchain. It has been generated by our counterparty and is used to derive
+	 *  channel state keys, which are then included in the witness script and committed to in the
+	 *  BIP 143 signature.
+	 * 
+	 *  An `Err` can be returned to signal that the signer is unavailable/cannot produce a valid
+	 *  signature and should be retried later. Once the signer is ready to provide a signature after
+	 *  previously returning an `Err`, [`ChannelMonitor::signer_unblocked`] must be called on its
+	 *  monitor.
+	 * 
+	 *  [`ChannelMonitor::signer_unblocked`]: crate::chain::channelmonitor::ChannelMonitor::signer_unblocked
+	 */
+	inline LDK::CResult_ECDSASignatureNoneZ sign_counterparty_htlc_transaction(struct LDKTransaction htlc_tx, uintptr_t input, uint64_t amount, struct LDKPublicKey per_commitment_point, const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc);
+	/**
+	 *  Create a signature for a (proposed) closing transaction.
+	 * 
+	 *  Note that, due to rounding, there may be one "missing" satoshi, and either party may have
+	 *  chosen to forgo their output as dust.
+	 */
+	inline LDK::CResult_ECDSASignatureNoneZ sign_closing_transaction(const struct LDKClosingTransaction *NONNULL_PTR closing_tx);
+	/**
+	 *  Computes the signature for a commitment transaction's anchor output used as an
+	 *  input within `anchor_tx`, which spends the commitment transaction, at index `input`.
+	 * 
+	 *  An `Err` can be returned to signal that the signer is unavailable/cannot produce a valid
+	 *  signature and should be retried later. Once the signer is ready to provide a signature after
+	 *  previously returning an `Err`, [`ChannelMonitor::signer_unblocked`] must be called on its
+	 *  monitor.
+	 * 
+	 *  [`ChannelMonitor::signer_unblocked`]: crate::chain::channelmonitor::ChannelMonitor::signer_unblocked
+	 */
+	inline LDK::CResult_ECDSASignatureNoneZ sign_holder_anchor_input(struct LDKTransaction anchor_tx, uintptr_t input);
+	/**
+	 *  Signs a channel announcement message with our funding key proving it comes from one of the
+	 *  channel participants.
+	 * 
+	 *  Channel announcements also require a signature from each node's network key. Our node
+	 *  signature is computed through [`NodeSigner::sign_gossip_message`].
+	 * 
+	 *  Note that if this fails or is rejected, the channel will not be publicly announced and
+	 *  our counterparty may (though likely will not) close the channel on us for violating the
+	 *  protocol.
+	 * 
+	 *  [`NodeSigner::sign_gossip_message`]: crate::sign::NodeSigner::sign_gossip_message
+	 */
+	inline LDK::CResult_ECDSASignatureNoneZ sign_channel_announcement_with_funding_key(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg);
+};
+class ChannelMonitorUpdate {
+private:
+	LDKChannelMonitorUpdate self;
+public:
+	ChannelMonitorUpdate(const ChannelMonitorUpdate&) = delete;
+	ChannelMonitorUpdate(ChannelMonitorUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitorUpdate)); }
+	ChannelMonitorUpdate(LDKChannelMonitorUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitorUpdate)); }
+	operator LDKChannelMonitorUpdate() && { LDKChannelMonitorUpdate res = self; memset(&self, 0, sizeof(LDKChannelMonitorUpdate)); return res; }
+	~ChannelMonitorUpdate() { ChannelMonitorUpdate_free(self); }
+	ChannelMonitorUpdate& operator=(ChannelMonitorUpdate&& o) { ChannelMonitorUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMonitorUpdate)); return *this; }
+	LDKChannelMonitorUpdate* operator &() { return &self; }
+	LDKChannelMonitorUpdate* operator ->() { return &self; }
+	const LDKChannelMonitorUpdate* operator &() const { return &self; }
+	const LDKChannelMonitorUpdate* operator ->() const { return &self; }
+};
+class MonitorEvent {
+private:
+	LDKMonitorEvent self;
+public:
+	MonitorEvent(const MonitorEvent&) = delete;
+	MonitorEvent(MonitorEvent&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorEvent)); }
+	MonitorEvent(LDKMonitorEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorEvent)); }
+	operator LDKMonitorEvent() && { LDKMonitorEvent res = self; memset(&self, 0, sizeof(LDKMonitorEvent)); return res; }
+	~MonitorEvent() { MonitorEvent_free(self); }
+	MonitorEvent& operator=(MonitorEvent&& o) { MonitorEvent_free(self); self = o.self; memset(&o, 0, sizeof(MonitorEvent)); return *this; }
+	LDKMonitorEvent* operator &() { return &self; }
+	LDKMonitorEvent* operator ->() { return &self; }
+	const LDKMonitorEvent* operator &() const { return &self; }
+	const LDKMonitorEvent* operator ->() const { return &self; }
+};
+class HTLCUpdate {
+private:
+	LDKHTLCUpdate self;
+public:
+	HTLCUpdate(const HTLCUpdate&) = delete;
+	HTLCUpdate(HTLCUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCUpdate)); }
+	HTLCUpdate(LDKHTLCUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCUpdate)); }
+	operator LDKHTLCUpdate() && { LDKHTLCUpdate res = self; memset(&self, 0, sizeof(LDKHTLCUpdate)); return res; }
+	~HTLCUpdate() { HTLCUpdate_free(self); }
+	HTLCUpdate& operator=(HTLCUpdate&& o) { HTLCUpdate_free(self); self = o.self; memset(&o, 0, sizeof(HTLCUpdate)); return *this; }
+	LDKHTLCUpdate* operator &() { return &self; }
+	LDKHTLCUpdate* operator ->() { return &self; }
+	const LDKHTLCUpdate* operator &() const { return &self; }
+	const LDKHTLCUpdate* operator ->() const { return &self; }
+};
+class BalanceSource {
+private:
+	LDKBalanceSource self;
+public:
+	BalanceSource(const BalanceSource&) = delete;
+	BalanceSource(BalanceSource&& o) : self(o.self) { memset(&o, 0, sizeof(BalanceSource)); }
+	BalanceSource(LDKBalanceSource&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBalanceSource)); }
+	operator LDKBalanceSource() && { LDKBalanceSource res = self; memset(&self, 0, sizeof(LDKBalanceSource)); return res; }
+	BalanceSource& operator=(BalanceSource&& o) { self = o.self; memset(&o, 0, sizeof(BalanceSource)); return *this; }
+	LDKBalanceSource* operator &() { return &self; }
+	LDKBalanceSource* operator ->() { return &self; }
+	const LDKBalanceSource* operator &() const { return &self; }
+	const LDKBalanceSource* operator ->() const { return &self; }
+};
 class Balance {
 private:
 	LDKBalance self;
@@ -2966,6 +3375,18 @@ public:
 	 *  connection to the node exists, then the message is simply not sent.
 	 */
 	inline LDK::CVec_C2Tuple_PublicKeyTypeZZ get_and_clear_pending_msg();
+	/**
+	 *  Indicates a peer disconnected.
+	 */
+	inline void peer_disconnected(struct LDKPublicKey their_node_id);
+	/**
+	 *  Handle a peer connecting.
+	 * 
+	 *  May return an `Err(())` if the features the peer supports are not sufficient to communicate
+	 *  with us. Implementors should be somewhat conservative about doing so, however, as other
+	 *  message handlers may still wish to communicate with this peer.
+	 */
+	inline LDK::CResult_NoneNoneZ peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg, bool inbound);
 	/**
 	 *  Gets the node feature flags which this handler itself supports. All available handlers are
 	 *  queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
@@ -3077,6 +3498,21 @@ public:
 	 */
 	inline uint64_t hash();
 };
+class PeerDetails {
+private:
+	LDKPeerDetails self;
+public:
+	PeerDetails(const PeerDetails&) = delete;
+	PeerDetails(PeerDetails&& o) : self(o.self) { memset(&o, 0, sizeof(PeerDetails)); }
+	PeerDetails(LDKPeerDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeerDetails)); }
+	operator LDKPeerDetails() && { LDKPeerDetails res = self; memset(&self, 0, sizeof(LDKPeerDetails)); return res; }
+	~PeerDetails() { PeerDetails_free(self); }
+	PeerDetails& operator=(PeerDetails&& o) { PeerDetails_free(self); self = o.self; memset(&o, 0, sizeof(PeerDetails)); return *this; }
+	LDKPeerDetails* operator &() { return &self; }
+	LDKPeerDetails* operator ->() { return &self; }
+	const LDKPeerDetails* operator &() const { return &self; }
+	const LDKPeerDetails* operator ->() const { return &self; }
+};
 class PeerHandleError {
 private:
 	LDKPeerHandleError self;
@@ -3107,6 +3543,21 @@ public:
 	const LDKPeerManager* operator &() const { return &self; }
 	const LDKPeerManager* operator ->() const { return &self; }
 };
+class GraphSyncError {
+private:
+	LDKGraphSyncError self;
+public:
+	GraphSyncError(const GraphSyncError&) = delete;
+	GraphSyncError(GraphSyncError&& o) : self(o.self) { memset(&o, 0, sizeof(GraphSyncError)); }
+	GraphSyncError(LDKGraphSyncError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKGraphSyncError)); }
+	operator LDKGraphSyncError() && { LDKGraphSyncError res = self; memset(&self, 0, sizeof(LDKGraphSyncError)); return res; }
+	~GraphSyncError() { GraphSyncError_free(self); }
+	GraphSyncError& operator=(GraphSyncError&& o) { GraphSyncError_free(self); self = o.self; memset(&o, 0, sizeof(GraphSyncError)); return *this; }
+	LDKGraphSyncError* operator &() { return &self; }
+	LDKGraphSyncError* operator ->() { return &self; }
+	const LDKGraphSyncError* operator &() const { return &self; }
+	const LDKGraphSyncError* operator ->() const { return &self; }
+};
 class RapidGossipSync {
 private:
 	LDKRapidGossipSync self;
@@ -3196,6 +3647,8 @@ public:
 	const LDKPersister* operator ->() const { return &self; }
 	/**
 	 *  Persist the given ['ChannelManager'] to disk, returning an error if persistence failed.
+	 * 
+	 *  [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
 	 */
 	inline LDK::CResult_NoneIOErrorZ persist_manager(const struct LDKChannelManager *NONNULL_PTR channel_manager);
 	/**
@@ -3222,6 +3675,36 @@ public:
 	const LDKMonitorUpdatingPersister* operator &() const { return &self; }
 	const LDKMonitorUpdatingPersister* operator ->() const { return &self; }
 };
+class InvoiceRequestWithExplicitPayerIdBuilder {
+private:
+	LDKInvoiceRequestWithExplicitPayerIdBuilder self;
+public:
+	InvoiceRequestWithExplicitPayerIdBuilder(const InvoiceRequestWithExplicitPayerIdBuilder&) = delete;
+	InvoiceRequestWithExplicitPayerIdBuilder(InvoiceRequestWithExplicitPayerIdBuilder&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceRequestWithExplicitPayerIdBuilder)); }
+	InvoiceRequestWithExplicitPayerIdBuilder(LDKInvoiceRequestWithExplicitPayerIdBuilder&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceRequestWithExplicitPayerIdBuilder)); }
+	operator LDKInvoiceRequestWithExplicitPayerIdBuilder() && { LDKInvoiceRequestWithExplicitPayerIdBuilder res = self; memset(&self, 0, sizeof(LDKInvoiceRequestWithExplicitPayerIdBuilder)); return res; }
+	~InvoiceRequestWithExplicitPayerIdBuilder() { InvoiceRequestWithExplicitPayerIdBuilder_free(self); }
+	InvoiceRequestWithExplicitPayerIdBuilder& operator=(InvoiceRequestWithExplicitPayerIdBuilder&& o) { InvoiceRequestWithExplicitPayerIdBuilder_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceRequestWithExplicitPayerIdBuilder)); return *this; }
+	LDKInvoiceRequestWithExplicitPayerIdBuilder* operator &() { return &self; }
+	LDKInvoiceRequestWithExplicitPayerIdBuilder* operator ->() { return &self; }
+	const LDKInvoiceRequestWithExplicitPayerIdBuilder* operator &() const { return &self; }
+	const LDKInvoiceRequestWithExplicitPayerIdBuilder* operator ->() const { return &self; }
+};
+class InvoiceRequestWithDerivedPayerIdBuilder {
+private:
+	LDKInvoiceRequestWithDerivedPayerIdBuilder self;
+public:
+	InvoiceRequestWithDerivedPayerIdBuilder(const InvoiceRequestWithDerivedPayerIdBuilder&) = delete;
+	InvoiceRequestWithDerivedPayerIdBuilder(InvoiceRequestWithDerivedPayerIdBuilder&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceRequestWithDerivedPayerIdBuilder)); }
+	InvoiceRequestWithDerivedPayerIdBuilder(LDKInvoiceRequestWithDerivedPayerIdBuilder&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceRequestWithDerivedPayerIdBuilder)); }
+	operator LDKInvoiceRequestWithDerivedPayerIdBuilder() && { LDKInvoiceRequestWithDerivedPayerIdBuilder res = self; memset(&self, 0, sizeof(LDKInvoiceRequestWithDerivedPayerIdBuilder)); return res; }
+	~InvoiceRequestWithDerivedPayerIdBuilder() { InvoiceRequestWithDerivedPayerIdBuilder_free(self); }
+	InvoiceRequestWithDerivedPayerIdBuilder& operator=(InvoiceRequestWithDerivedPayerIdBuilder&& o) { InvoiceRequestWithDerivedPayerIdBuilder_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceRequestWithDerivedPayerIdBuilder)); return *this; }
+	LDKInvoiceRequestWithDerivedPayerIdBuilder* operator &() { return &self; }
+	LDKInvoiceRequestWithDerivedPayerIdBuilder* operator ->() { return &self; }
+	const LDKInvoiceRequestWithDerivedPayerIdBuilder* operator &() const { return &self; }
+	const LDKInvoiceRequestWithDerivedPayerIdBuilder* operator ->() const { return &self; }
+};
 class UnsignedInvoiceRequest {
 private:
 	LDKUnsignedInvoiceRequest self;
@@ -3237,6 +3720,25 @@ public:
 	const LDKUnsignedInvoiceRequest* operator &() const { return &self; }
 	const LDKUnsignedInvoiceRequest* operator ->() const { return &self; }
 };
+class SignInvoiceRequestFn {
+private:
+	LDKSignInvoiceRequestFn self;
+public:
+	SignInvoiceRequestFn(const SignInvoiceRequestFn&) = delete;
+	SignInvoiceRequestFn(SignInvoiceRequestFn&& o) : self(o.self) { memset(&o, 0, sizeof(SignInvoiceRequestFn)); }
+	SignInvoiceRequestFn(LDKSignInvoiceRequestFn&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignInvoiceRequestFn)); }
+	operator LDKSignInvoiceRequestFn() && { LDKSignInvoiceRequestFn res = self; memset(&self, 0, sizeof(LDKSignInvoiceRequestFn)); return res; }
+	~SignInvoiceRequestFn() { SignInvoiceRequestFn_free(self); }
+	SignInvoiceRequestFn& operator=(SignInvoiceRequestFn&& o) { SignInvoiceRequestFn_free(self); self = o.self; memset(&o, 0, sizeof(SignInvoiceRequestFn)); return *this; }
+	LDKSignInvoiceRequestFn* operator &() { return &self; }
+	LDKSignInvoiceRequestFn* operator ->() { return &self; }
+	const LDKSignInvoiceRequestFn* operator &() const { return &self; }
+	const LDKSignInvoiceRequestFn* operator ->() const { return &self; }
+	/**
+	 *  Signs a [`TaggedHash`] computed over the merkle root of `message`'s TLV stream.
+	 */
+	inline LDK::CResult_SchnorrSignatureNoneZ sign_invoice_request(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR message);
+};
 class InvoiceRequest {
 private:
 	LDKInvoiceRequest self;
@@ -3267,6 +3769,21 @@ public:
 	const LDKVerifiedInvoiceRequest* operator &() const { return &self; }
 	const LDKVerifiedInvoiceRequest* operator ->() const { return &self; }
 };
+class InvoiceRequestFields {
+private:
+	LDKInvoiceRequestFields self;
+public:
+	InvoiceRequestFields(const InvoiceRequestFields&) = delete;
+	InvoiceRequestFields(InvoiceRequestFields&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceRequestFields)); }
+	InvoiceRequestFields(LDKInvoiceRequestFields&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceRequestFields)); }
+	operator LDKInvoiceRequestFields() && { LDKInvoiceRequestFields res = self; memset(&self, 0, sizeof(LDKInvoiceRequestFields)); return res; }
+	~InvoiceRequestFields() { InvoiceRequestFields_free(self); }
+	InvoiceRequestFields& operator=(InvoiceRequestFields&& o) { InvoiceRequestFields_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceRequestFields)); return *this; }
+	LDKInvoiceRequestFields* operator &() { return &self; }
+	LDKInvoiceRequestFields* operator ->() { return &self; }
+	const LDKInvoiceRequestFields* operator &() const { return &self; }
+	const LDKInvoiceRequestFields* operator ->() const { return &self; }
+};
 class DecodeError {
 private:
 	LDKDecodeError self;
@@ -3357,6 +3874,36 @@ public:
 	const LDKPong* operator &() const { return &self; }
 	const LDKPong* operator ->() const { return &self; }
 };
+class CommonOpenChannelFields {
+private:
+	LDKCommonOpenChannelFields self;
+public:
+	CommonOpenChannelFields(const CommonOpenChannelFields&) = delete;
+	CommonOpenChannelFields(CommonOpenChannelFields&& o) : self(o.self) { memset(&o, 0, sizeof(CommonOpenChannelFields)); }
+	CommonOpenChannelFields(LDKCommonOpenChannelFields&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommonOpenChannelFields)); }
+	operator LDKCommonOpenChannelFields() && { LDKCommonOpenChannelFields res = self; memset(&self, 0, sizeof(LDKCommonOpenChannelFields)); return res; }
+	~CommonOpenChannelFields() { CommonOpenChannelFields_free(self); }
+	CommonOpenChannelFields& operator=(CommonOpenChannelFields&& o) { CommonOpenChannelFields_free(self); self = o.self; memset(&o, 0, sizeof(CommonOpenChannelFields)); return *this; }
+	LDKCommonOpenChannelFields* operator &() { return &self; }
+	LDKCommonOpenChannelFields* operator ->() { return &self; }
+	const LDKCommonOpenChannelFields* operator &() const { return &self; }
+	const LDKCommonOpenChannelFields* operator ->() const { return &self; }
+};
+class ChannelParameters {
+private:
+	LDKChannelParameters self;
+public:
+	ChannelParameters(const ChannelParameters&) = delete;
+	ChannelParameters(ChannelParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelParameters)); }
+	ChannelParameters(LDKChannelParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelParameters)); }
+	operator LDKChannelParameters() && { LDKChannelParameters res = self; memset(&self, 0, sizeof(LDKChannelParameters)); return res; }
+	~ChannelParameters() { ChannelParameters_free(self); }
+	ChannelParameters& operator=(ChannelParameters&& o) { ChannelParameters_free(self); self = o.self; memset(&o, 0, sizeof(ChannelParameters)); return *this; }
+	LDKChannelParameters* operator &() { return &self; }
+	LDKChannelParameters* operator ->() { return &self; }
+	const LDKChannelParameters* operator &() const { return &self; }
+	const LDKChannelParameters* operator ->() const { return &self; }
+};
 class OpenChannel {
 private:
 	LDKOpenChannel self;
@@ -3387,6 +3934,21 @@ public:
 	const LDKOpenChannelV2* operator &() const { return &self; }
 	const LDKOpenChannelV2* operator ->() const { return &self; }
 };
+class CommonAcceptChannelFields {
+private:
+	LDKCommonAcceptChannelFields self;
+public:
+	CommonAcceptChannelFields(const CommonAcceptChannelFields&) = delete;
+	CommonAcceptChannelFields(CommonAcceptChannelFields&& o) : self(o.self) { memset(&o, 0, sizeof(CommonAcceptChannelFields)); }
+	CommonAcceptChannelFields(LDKCommonAcceptChannelFields&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommonAcceptChannelFields)); }
+	operator LDKCommonAcceptChannelFields() && { LDKCommonAcceptChannelFields res = self; memset(&self, 0, sizeof(LDKCommonAcceptChannelFields)); return res; }
+	~CommonAcceptChannelFields() { CommonAcceptChannelFields_free(self); }
+	CommonAcceptChannelFields& operator=(CommonAcceptChannelFields&& o) { CommonAcceptChannelFields_free(self); self = o.self; memset(&o, 0, sizeof(CommonAcceptChannelFields)); return *this; }
+	LDKCommonAcceptChannelFields* operator &() { return &self; }
+	LDKCommonAcceptChannelFields* operator ->() { return &self; }
+	const LDKCommonAcceptChannelFields* operator &() const { return &self; }
+	const LDKCommonAcceptChannelFields* operator ->() const { return &self; }
+};
 class AcceptChannel {
 private:
 	LDKAcceptChannel self;
@@ -3462,6 +4024,66 @@ public:
 	const LDKChannelReady* operator &() const { return &self; }
 	const LDKChannelReady* operator ->() const { return &self; }
 };
+class Stfu {
+private:
+	LDKStfu self;
+public:
+	Stfu(const Stfu&) = delete;
+	Stfu(Stfu&& o) : self(o.self) { memset(&o, 0, sizeof(Stfu)); }
+	Stfu(LDKStfu&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKStfu)); }
+	operator LDKStfu() && { LDKStfu res = self; memset(&self, 0, sizeof(LDKStfu)); return res; }
+	~Stfu() { Stfu_free(self); }
+	Stfu& operator=(Stfu&& o) { Stfu_free(self); self = o.self; memset(&o, 0, sizeof(Stfu)); return *this; }
+	LDKStfu* operator &() { return &self; }
+	LDKStfu* operator ->() { return &self; }
+	const LDKStfu* operator &() const { return &self; }
+	const LDKStfu* operator ->() const { return &self; }
+};
+class SpliceInit {
+private:
+	LDKSpliceInit self;
+public:
+	SpliceInit(const SpliceInit&) = delete;
+	SpliceInit(SpliceInit&& o) : self(o.self) { memset(&o, 0, sizeof(SpliceInit)); }
+	SpliceInit(LDKSpliceInit&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSpliceInit)); }
+	operator LDKSpliceInit() && { LDKSpliceInit res = self; memset(&self, 0, sizeof(LDKSpliceInit)); return res; }
+	~SpliceInit() { SpliceInit_free(self); }
+	SpliceInit& operator=(SpliceInit&& o) { SpliceInit_free(self); self = o.self; memset(&o, 0, sizeof(SpliceInit)); return *this; }
+	LDKSpliceInit* operator &() { return &self; }
+	LDKSpliceInit* operator ->() { return &self; }
+	const LDKSpliceInit* operator &() const { return &self; }
+	const LDKSpliceInit* operator ->() const { return &self; }
+};
+class SpliceAck {
+private:
+	LDKSpliceAck self;
+public:
+	SpliceAck(const SpliceAck&) = delete;
+	SpliceAck(SpliceAck&& o) : self(o.self) { memset(&o, 0, sizeof(SpliceAck)); }
+	SpliceAck(LDKSpliceAck&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSpliceAck)); }
+	operator LDKSpliceAck() && { LDKSpliceAck res = self; memset(&self, 0, sizeof(LDKSpliceAck)); return res; }
+	~SpliceAck() { SpliceAck_free(self); }
+	SpliceAck& operator=(SpliceAck&& o) { SpliceAck_free(self); self = o.self; memset(&o, 0, sizeof(SpliceAck)); return *this; }
+	LDKSpliceAck* operator &() { return &self; }
+	LDKSpliceAck* operator ->() { return &self; }
+	const LDKSpliceAck* operator &() const { return &self; }
+	const LDKSpliceAck* operator ->() const { return &self; }
+};
+class SpliceLocked {
+private:
+	LDKSpliceLocked self;
+public:
+	SpliceLocked(const SpliceLocked&) = delete;
+	SpliceLocked(SpliceLocked&& o) : self(o.self) { memset(&o, 0, sizeof(SpliceLocked)); }
+	SpliceLocked(LDKSpliceLocked&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSpliceLocked)); }
+	operator LDKSpliceLocked() && { LDKSpliceLocked res = self; memset(&self, 0, sizeof(LDKSpliceLocked)); return res; }
+	~SpliceLocked() { SpliceLocked_free(self); }
+	SpliceLocked& operator=(SpliceLocked&& o) { SpliceLocked_free(self); self = o.self; memset(&o, 0, sizeof(SpliceLocked)); return *this; }
+	LDKSpliceLocked* operator &() { return &self; }
+	LDKSpliceLocked* operator ->() { return &self; }
+	const LDKSpliceLocked* operator &() const { return &self; }
+	const LDKSpliceLocked* operator ->() const { return &self; }
+};
 class TxAddInput {
 private:
 	LDKTxAddInput self;
@@ -3717,6 +4339,21 @@ public:
 	const LDKUpdateFailMalformedHTLC* operator &() const { return &self; }
 	const LDKUpdateFailMalformedHTLC* operator ->() const { return &self; }
 };
+class CommitmentSignedBatch {
+private:
+	LDKCommitmentSignedBatch self;
+public:
+	CommitmentSignedBatch(const CommitmentSignedBatch&) = delete;
+	CommitmentSignedBatch(CommitmentSignedBatch&& o) : self(o.self) { memset(&o, 0, sizeof(CommitmentSignedBatch)); }
+	CommitmentSignedBatch(LDKCommitmentSignedBatch&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommitmentSignedBatch)); }
+	operator LDKCommitmentSignedBatch() && { LDKCommitmentSignedBatch res = self; memset(&self, 0, sizeof(LDKCommitmentSignedBatch)); return res; }
+	~CommitmentSignedBatch() { CommitmentSignedBatch_free(self); }
+	CommitmentSignedBatch& operator=(CommitmentSignedBatch&& o) { CommitmentSignedBatch_free(self); self = o.self; memset(&o, 0, sizeof(CommitmentSignedBatch)); return *this; }
+	LDKCommitmentSignedBatch* operator &() { return &self; }
+	LDKCommitmentSignedBatch* operator ->() { return &self; }
+	const LDKCommitmentSignedBatch* operator &() const { return &self; }
+	const LDKCommitmentSignedBatch* operator ->() const { return &self; }
+};
 class CommitmentSigned {
 private:
 	LDKCommitmentSigned self;
@@ -4096,6 +4733,10 @@ public:
 	 *  Handle an incoming `closing_signed` message from the given peer.
 	 */
 	inline void handle_closing_signed(struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg);
+	/**
+	 *  Handle an incoming `stfu` message from the given peer.
+	 */
+	inline void handle_stfu(struct LDKPublicKey their_node_id, const struct LDKStfu *NONNULL_PTR msg);
 	/**
 	 *  Handle an incoming `tx_add_input message` from the given peer.
 	 */
@@ -4348,6 +4989,11 @@ public:
 	 *  drop and refuse to forward onion messages to this peer.
 	 */
 	inline void peer_disconnected(struct LDKPublicKey their_node_id);
+	/**
+	 *  Performs actions that should happen roughly every ten seconds after startup. Allows handlers
+	 *  to drop any buffered onion messages intended for prospective peers.
+	 */
+	inline void timer_tick_occurred();
 	/**
 	 *  Gets the node feature flags which this handler itself supports. All available handlers are
 	 *  queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
@@ -4363,6 +5009,51 @@ public:
 	 */
 	inline LDK::InitFeatures provided_init_features(struct LDKPublicKey their_node_id);
 };
+class FinalOnionHopData {
+private:
+	LDKFinalOnionHopData self;
+public:
+	FinalOnionHopData(const FinalOnionHopData&) = delete;
+	FinalOnionHopData(FinalOnionHopData&& o) : self(o.self) { memset(&o, 0, sizeof(FinalOnionHopData)); }
+	FinalOnionHopData(LDKFinalOnionHopData&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFinalOnionHopData)); }
+	operator LDKFinalOnionHopData() && { LDKFinalOnionHopData res = self; memset(&self, 0, sizeof(LDKFinalOnionHopData)); return res; }
+	~FinalOnionHopData() { FinalOnionHopData_free(self); }
+	FinalOnionHopData& operator=(FinalOnionHopData&& o) { FinalOnionHopData_free(self); self = o.self; memset(&o, 0, sizeof(FinalOnionHopData)); return *this; }
+	LDKFinalOnionHopData* operator &() { return &self; }
+	LDKFinalOnionHopData* operator ->() { return &self; }
+	const LDKFinalOnionHopData* operator &() const { return &self; }
+	const LDKFinalOnionHopData* operator ->() const { return &self; }
+};
+class OnionPacket {
+private:
+	LDKOnionPacket self;
+public:
+	OnionPacket(const OnionPacket&) = delete;
+	OnionPacket(OnionPacket&& o) : self(o.self) { memset(&o, 0, sizeof(OnionPacket)); }
+	OnionPacket(LDKOnionPacket&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionPacket)); }
+	operator LDKOnionPacket() && { LDKOnionPacket res = self; memset(&self, 0, sizeof(LDKOnionPacket)); return res; }
+	~OnionPacket() { OnionPacket_free(self); }
+	OnionPacket& operator=(OnionPacket&& o) { OnionPacket_free(self); self = o.self; memset(&o, 0, sizeof(OnionPacket)); return *this; }
+	LDKOnionPacket* operator &() { return &self; }
+	LDKOnionPacket* operator ->() { return &self; }
+	const LDKOnionPacket* operator &() const { return &self; }
+	const LDKOnionPacket* operator ->() const { return &self; }
+};
+class TrampolineOnionPacket {
+private:
+	LDKTrampolineOnionPacket self;
+public:
+	TrampolineOnionPacket(const TrampolineOnionPacket&) = delete;
+	TrampolineOnionPacket(TrampolineOnionPacket&& o) : self(o.self) { memset(&o, 0, sizeof(TrampolineOnionPacket)); }
+	TrampolineOnionPacket(LDKTrampolineOnionPacket&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTrampolineOnionPacket)); }
+	operator LDKTrampolineOnionPacket() && { LDKTrampolineOnionPacket res = self; memset(&self, 0, sizeof(LDKTrampolineOnionPacket)); return res; }
+	~TrampolineOnionPacket() { TrampolineOnionPacket_free(self); }
+	TrampolineOnionPacket& operator=(TrampolineOnionPacket&& o) { TrampolineOnionPacket_free(self); self = o.self; memset(&o, 0, sizeof(TrampolineOnionPacket)); return *this; }
+	LDKTrampolineOnionPacket* operator &() { return &self; }
+	LDKTrampolineOnionPacket* operator ->() { return &self; }
+	const LDKTrampolineOnionPacket* operator &() const { return &self; }
+	const LDKTrampolineOnionPacket* operator ->() const { return &self; }
+};
 class Level {
 private:
 	LDKLevel self;
@@ -4407,17 +5098,134 @@ public:
 	const LDKLogger* operator &() const { return &self; }
 	const LDKLogger* operator ->() const { return &self; }
 	/**
-	 *  Logs the `Record`
+	 *  Logs the [`Record`].
 	 */
-	inline void log(const struct LDKRecord *NONNULL_PTR record);
+	inline void log(struct LDKRecord record);
 };
-class FutureCallback {
+class InboundHTLCStateDetails {
 private:
-	LDKFutureCallback self;
+	LDKInboundHTLCStateDetails self;
 public:
-	FutureCallback(const FutureCallback&) = delete;
-	FutureCallback(FutureCallback&& o) : self(o.self) { memset(&o, 0, sizeof(FutureCallback)); }
-	FutureCallback(LDKFutureCallback&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFutureCallback)); }
+	InboundHTLCStateDetails(const InboundHTLCStateDetails&) = delete;
+	InboundHTLCStateDetails(InboundHTLCStateDetails&& o) : self(o.self) { memset(&o, 0, sizeof(InboundHTLCStateDetails)); }
+	InboundHTLCStateDetails(LDKInboundHTLCStateDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInboundHTLCStateDetails)); }
+	operator LDKInboundHTLCStateDetails() && { LDKInboundHTLCStateDetails res = self; memset(&self, 0, sizeof(LDKInboundHTLCStateDetails)); return res; }
+	InboundHTLCStateDetails& operator=(InboundHTLCStateDetails&& o) { self = o.self; memset(&o, 0, sizeof(InboundHTLCStateDetails)); return *this; }
+	LDKInboundHTLCStateDetails* operator &() { return &self; }
+	LDKInboundHTLCStateDetails* operator ->() { return &self; }
+	const LDKInboundHTLCStateDetails* operator &() const { return &self; }
+	const LDKInboundHTLCStateDetails* operator ->() const { return &self; }
+};
+class InboundHTLCDetails {
+private:
+	LDKInboundHTLCDetails self;
+public:
+	InboundHTLCDetails(const InboundHTLCDetails&) = delete;
+	InboundHTLCDetails(InboundHTLCDetails&& o) : self(o.self) { memset(&o, 0, sizeof(InboundHTLCDetails)); }
+	InboundHTLCDetails(LDKInboundHTLCDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInboundHTLCDetails)); }
+	operator LDKInboundHTLCDetails() && { LDKInboundHTLCDetails res = self; memset(&self, 0, sizeof(LDKInboundHTLCDetails)); return res; }
+	~InboundHTLCDetails() { InboundHTLCDetails_free(self); }
+	InboundHTLCDetails& operator=(InboundHTLCDetails&& o) { InboundHTLCDetails_free(self); self = o.self; memset(&o, 0, sizeof(InboundHTLCDetails)); return *this; }
+	LDKInboundHTLCDetails* operator &() { return &self; }
+	LDKInboundHTLCDetails* operator ->() { return &self; }
+	const LDKInboundHTLCDetails* operator &() const { return &self; }
+	const LDKInboundHTLCDetails* operator ->() const { return &self; }
+};
+class OutboundHTLCStateDetails {
+private:
+	LDKOutboundHTLCStateDetails self;
+public:
+	OutboundHTLCStateDetails(const OutboundHTLCStateDetails&) = delete;
+	OutboundHTLCStateDetails(OutboundHTLCStateDetails&& o) : self(o.self) { memset(&o, 0, sizeof(OutboundHTLCStateDetails)); }
+	OutboundHTLCStateDetails(LDKOutboundHTLCStateDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOutboundHTLCStateDetails)); }
+	operator LDKOutboundHTLCStateDetails() && { LDKOutboundHTLCStateDetails res = self; memset(&self, 0, sizeof(LDKOutboundHTLCStateDetails)); return res; }
+	OutboundHTLCStateDetails& operator=(OutboundHTLCStateDetails&& o) { self = o.self; memset(&o, 0, sizeof(OutboundHTLCStateDetails)); return *this; }
+	LDKOutboundHTLCStateDetails* operator &() { return &self; }
+	LDKOutboundHTLCStateDetails* operator ->() { return &self; }
+	const LDKOutboundHTLCStateDetails* operator &() const { return &self; }
+	const LDKOutboundHTLCStateDetails* operator ->() const { return &self; }
+};
+class OutboundHTLCDetails {
+private:
+	LDKOutboundHTLCDetails self;
+public:
+	OutboundHTLCDetails(const OutboundHTLCDetails&) = delete;
+	OutboundHTLCDetails(OutboundHTLCDetails&& o) : self(o.self) { memset(&o, 0, sizeof(OutboundHTLCDetails)); }
+	OutboundHTLCDetails(LDKOutboundHTLCDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOutboundHTLCDetails)); }
+	operator LDKOutboundHTLCDetails() && { LDKOutboundHTLCDetails res = self; memset(&self, 0, sizeof(LDKOutboundHTLCDetails)); return res; }
+	~OutboundHTLCDetails() { OutboundHTLCDetails_free(self); }
+	OutboundHTLCDetails& operator=(OutboundHTLCDetails&& o) { OutboundHTLCDetails_free(self); self = o.self; memset(&o, 0, sizeof(OutboundHTLCDetails)); return *this; }
+	LDKOutboundHTLCDetails* operator &() { return &self; }
+	LDKOutboundHTLCDetails* operator ->() { return &self; }
+	const LDKOutboundHTLCDetails* operator &() const { return &self; }
+	const LDKOutboundHTLCDetails* operator ->() const { return &self; }
+};
+class CounterpartyForwardingInfo {
+private:
+	LDKCounterpartyForwardingInfo self;
+public:
+	CounterpartyForwardingInfo(const CounterpartyForwardingInfo&) = delete;
+	CounterpartyForwardingInfo(CounterpartyForwardingInfo&& o) : self(o.self) { memset(&o, 0, sizeof(CounterpartyForwardingInfo)); }
+	CounterpartyForwardingInfo(LDKCounterpartyForwardingInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCounterpartyForwardingInfo)); }
+	operator LDKCounterpartyForwardingInfo() && { LDKCounterpartyForwardingInfo res = self; memset(&self, 0, sizeof(LDKCounterpartyForwardingInfo)); return res; }
+	~CounterpartyForwardingInfo() { CounterpartyForwardingInfo_free(self); }
+	CounterpartyForwardingInfo& operator=(CounterpartyForwardingInfo&& o) { CounterpartyForwardingInfo_free(self); self = o.self; memset(&o, 0, sizeof(CounterpartyForwardingInfo)); return *this; }
+	LDKCounterpartyForwardingInfo* operator &() { return &self; }
+	LDKCounterpartyForwardingInfo* operator ->() { return &self; }
+	const LDKCounterpartyForwardingInfo* operator &() const { return &self; }
+	const LDKCounterpartyForwardingInfo* operator ->() const { return &self; }
+};
+class ChannelCounterparty {
+private:
+	LDKChannelCounterparty self;
+public:
+	ChannelCounterparty(const ChannelCounterparty&) = delete;
+	ChannelCounterparty(ChannelCounterparty&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelCounterparty)); }
+	ChannelCounterparty(LDKChannelCounterparty&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelCounterparty)); }
+	operator LDKChannelCounterparty() && { LDKChannelCounterparty res = self; memset(&self, 0, sizeof(LDKChannelCounterparty)); return res; }
+	~ChannelCounterparty() { ChannelCounterparty_free(self); }
+	ChannelCounterparty& operator=(ChannelCounterparty&& o) { ChannelCounterparty_free(self); self = o.self; memset(&o, 0, sizeof(ChannelCounterparty)); return *this; }
+	LDKChannelCounterparty* operator &() { return &self; }
+	LDKChannelCounterparty* operator ->() { return &self; }
+	const LDKChannelCounterparty* operator &() const { return &self; }
+	const LDKChannelCounterparty* operator ->() const { return &self; }
+};
+class ChannelDetails {
+private:
+	LDKChannelDetails self;
+public:
+	ChannelDetails(const ChannelDetails&) = delete;
+	ChannelDetails(ChannelDetails&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelDetails)); }
+	ChannelDetails(LDKChannelDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelDetails)); }
+	operator LDKChannelDetails() && { LDKChannelDetails res = self; memset(&self, 0, sizeof(LDKChannelDetails)); return res; }
+	~ChannelDetails() { ChannelDetails_free(self); }
+	ChannelDetails& operator=(ChannelDetails&& o) { ChannelDetails_free(self); self = o.self; memset(&o, 0, sizeof(ChannelDetails)); return *this; }
+	LDKChannelDetails* operator &() { return &self; }
+	LDKChannelDetails* operator ->() { return &self; }
+	const LDKChannelDetails* operator &() const { return &self; }
+	const LDKChannelDetails* operator ->() const { return &self; }
+};
+class ChannelShutdownState {
+private:
+	LDKChannelShutdownState self;
+public:
+	ChannelShutdownState(const ChannelShutdownState&) = delete;
+	ChannelShutdownState(ChannelShutdownState&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelShutdownState)); }
+	ChannelShutdownState(LDKChannelShutdownState&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelShutdownState)); }
+	operator LDKChannelShutdownState() && { LDKChannelShutdownState res = self; memset(&self, 0, sizeof(LDKChannelShutdownState)); return res; }
+	ChannelShutdownState& operator=(ChannelShutdownState&& o) { self = o.self; memset(&o, 0, sizeof(ChannelShutdownState)); return *this; }
+	LDKChannelShutdownState* operator &() { return &self; }
+	LDKChannelShutdownState* operator ->() { return &self; }
+	const LDKChannelShutdownState* operator &() const { return &self; }
+	const LDKChannelShutdownState* operator ->() const { return &self; }
+};
+class FutureCallback {
+private:
+	LDKFutureCallback self;
+public:
+	FutureCallback(const FutureCallback&) = delete;
+	FutureCallback(FutureCallback&& o) : self(o.self) { memset(&o, 0, sizeof(FutureCallback)); }
+	FutureCallback(LDKFutureCallback&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFutureCallback)); }
 	operator LDKFutureCallback() && { LDKFutureCallback res = self; memset(&self, 0, sizeof(LDKFutureCallback)); return res; }
 	~FutureCallback() { FutureCallback_free(self); }
 	FutureCallback& operator=(FutureCallback&& o) { FutureCallback_free(self); self = o.self; memset(&o, 0, sizeof(FutureCallback)); return *this; }
@@ -4460,6 +5268,85 @@ public:
 	const LDKSleeper* operator &() const { return &self; }
 	const LDKSleeper* operator ->() const { return &self; }
 };
+class AsyncPaymentsMessageHandler {
+private:
+	LDKAsyncPaymentsMessageHandler self;
+public:
+	AsyncPaymentsMessageHandler(const AsyncPaymentsMessageHandler&) = delete;
+	AsyncPaymentsMessageHandler(AsyncPaymentsMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(AsyncPaymentsMessageHandler)); }
+	AsyncPaymentsMessageHandler(LDKAsyncPaymentsMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAsyncPaymentsMessageHandler)); }
+	operator LDKAsyncPaymentsMessageHandler() && { LDKAsyncPaymentsMessageHandler res = self; memset(&self, 0, sizeof(LDKAsyncPaymentsMessageHandler)); return res; }
+	~AsyncPaymentsMessageHandler() { AsyncPaymentsMessageHandler_free(self); }
+	AsyncPaymentsMessageHandler& operator=(AsyncPaymentsMessageHandler&& o) { AsyncPaymentsMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(AsyncPaymentsMessageHandler)); return *this; }
+	LDKAsyncPaymentsMessageHandler* operator &() { return &self; }
+	LDKAsyncPaymentsMessageHandler* operator ->() { return &self; }
+	const LDKAsyncPaymentsMessageHandler* operator &() const { return &self; }
+	const LDKAsyncPaymentsMessageHandler* operator ->() const { return &self; }
+	/**
+	 *  Handle a [`HeldHtlcAvailable`] message. A [`ReleaseHeldHtlc`] should be returned to release
+	 *  the held funds.
+	 * 
+	 *  Note that responder (or a relevant inner pointer) may be NULL or all-0s to represent None
+	 */
+	inline LDK::COption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ held_htlc_available(struct LDKHeldHtlcAvailable message, struct LDKResponder responder);
+	/**
+	 *  Handle a [`ReleaseHeldHtlc`] message. If authentication of the message succeeds, an HTLC
+	 *  should be released to the corresponding payee.
+	 */
+	inline void release_held_htlc(struct LDKReleaseHeldHtlc message);
+	/**
+	 *  Release any [`AsyncPaymentsMessage`]s that need to be sent.
+	 * 
+	 *  Typically, this is used for messages initiating an async payment flow rather than in response
+	 *  to another message.
+	 */
+	inline LDK::CVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ release_pending_messages();
+};
+class AsyncPaymentsMessage {
+private:
+	LDKAsyncPaymentsMessage self;
+public:
+	AsyncPaymentsMessage(const AsyncPaymentsMessage&) = delete;
+	AsyncPaymentsMessage(AsyncPaymentsMessage&& o) : self(o.self) { memset(&o, 0, sizeof(AsyncPaymentsMessage)); }
+	AsyncPaymentsMessage(LDKAsyncPaymentsMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAsyncPaymentsMessage)); }
+	operator LDKAsyncPaymentsMessage() && { LDKAsyncPaymentsMessage res = self; memset(&self, 0, sizeof(LDKAsyncPaymentsMessage)); return res; }
+	~AsyncPaymentsMessage() { AsyncPaymentsMessage_free(self); }
+	AsyncPaymentsMessage& operator=(AsyncPaymentsMessage&& o) { AsyncPaymentsMessage_free(self); self = o.self; memset(&o, 0, sizeof(AsyncPaymentsMessage)); return *this; }
+	LDKAsyncPaymentsMessage* operator &() { return &self; }
+	LDKAsyncPaymentsMessage* operator ->() { return &self; }
+	const LDKAsyncPaymentsMessage* operator &() const { return &self; }
+	const LDKAsyncPaymentsMessage* operator ->() const { return &self; }
+};
+class HeldHtlcAvailable {
+private:
+	LDKHeldHtlcAvailable self;
+public:
+	HeldHtlcAvailable(const HeldHtlcAvailable&) = delete;
+	HeldHtlcAvailable(HeldHtlcAvailable&& o) : self(o.self) { memset(&o, 0, sizeof(HeldHtlcAvailable)); }
+	HeldHtlcAvailable(LDKHeldHtlcAvailable&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHeldHtlcAvailable)); }
+	operator LDKHeldHtlcAvailable() && { LDKHeldHtlcAvailable res = self; memset(&self, 0, sizeof(LDKHeldHtlcAvailable)); return res; }
+	~HeldHtlcAvailable() { HeldHtlcAvailable_free(self); }
+	HeldHtlcAvailable& operator=(HeldHtlcAvailable&& o) { HeldHtlcAvailable_free(self); self = o.self; memset(&o, 0, sizeof(HeldHtlcAvailable)); return *this; }
+	LDKHeldHtlcAvailable* operator &() { return &self; }
+	LDKHeldHtlcAvailable* operator ->() { return &self; }
+	const LDKHeldHtlcAvailable* operator &() const { return &self; }
+	const LDKHeldHtlcAvailable* operator ->() const { return &self; }
+};
+class ReleaseHeldHtlc {
+private:
+	LDKReleaseHeldHtlc self;
+public:
+	ReleaseHeldHtlc(const ReleaseHeldHtlc&) = delete;
+	ReleaseHeldHtlc(ReleaseHeldHtlc&& o) : self(o.self) { memset(&o, 0, sizeof(ReleaseHeldHtlc)); }
+	ReleaseHeldHtlc(LDKReleaseHeldHtlc&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReleaseHeldHtlc)); }
+	operator LDKReleaseHeldHtlc() && { LDKReleaseHeldHtlc res = self; memset(&self, 0, sizeof(LDKReleaseHeldHtlc)); return res; }
+	~ReleaseHeldHtlc() { ReleaseHeldHtlc_free(self); }
+	ReleaseHeldHtlc& operator=(ReleaseHeldHtlc&& o) { ReleaseHeldHtlc_free(self); self = o.self; memset(&o, 0, sizeof(ReleaseHeldHtlc)); return *this; }
+	LDKReleaseHeldHtlc* operator &() { return &self; }
+	LDKReleaseHeldHtlc* operator ->() { return &self; }
+	const LDKReleaseHeldHtlc* operator &() const { return &self; }
+	const LDKReleaseHeldHtlc* operator ->() const { return &self; }
+};
 class OffersMessageHandler {
 private:
 	LDKOffersMessageHandler self;
@@ -4480,16 +5367,18 @@ public:
 	 * 
 	 *  The returned [`OffersMessage`], if any, is enqueued to be sent by [`OnionMessenger`].
 	 * 
-	 *  [`OnionMessenger`]: crate::onion_message::OnionMessenger
+	 *  [`OnionMessenger`]: crate::onion_message::messenger::OnionMessenger
+	 * 
+	 *  Note that responder (or a relevant inner pointer) may be NULL or all-0s to represent None
 	 */
-	inline LDK::COption_OffersMessageZ handle_message(struct LDKOffersMessage message);
+	inline LDK::COption_C2Tuple_OffersMessageResponseInstructionZZ handle_message(struct LDKOffersMessage message, struct LDKCOption_OffersContextZ context, struct LDKResponder responder);
 	/**
 	 *  Releases any [`OffersMessage`]s that need to be sent.
 	 * 
 	 *  Typically, this is used for messages initiating a payment flow rather than in response to
 	 *  another message. The latter should use the return value of [`Self::handle_message`].
 	 */
-	inline LDK::CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ release_pending_messages();
+	inline LDK::CVec_C2Tuple_OffersMessageMessageSendInstructionsZZ release_pending_messages();
 };
 class OffersMessage {
 private:
@@ -4801,7 +5690,7 @@ public:
 	 *  be sure to manage both cases correctly.
 	 * 
 	 *  Bitcoin transaction packages are defined in BIP 331 and here:
-	 *  https://github.com/bitcoin/bitcoin/blob/master/doc/policy/packages.md
+	 *  <https://github.com/bitcoin/bitcoin/blob/master/doc/policy/packages.md>
 	 */
 	inline void broadcast_transactions(struct LDKCVec_TransactionZ txs);
 };
@@ -4893,6 +5782,29 @@ public:
 	 *  Returns the TLV type identifying the message contents. MUST be >= 64.
 	 */
 	inline uint64_t tlv_type();
+	/**
+	 *  Returns the message type
+	 */
+	inline LDK::Str msg_type();
+	/**
+	 * Return a human-readable "debug" string describing this object
+	 */
+	inline LDK::Str debug_str();
+};
+class FundingInfo {
+private:
+	LDKFundingInfo self;
+public:
+	FundingInfo(const FundingInfo&) = delete;
+	FundingInfo(FundingInfo&& o) : self(o.self) { memset(&o, 0, sizeof(FundingInfo)); }
+	FundingInfo(LDKFundingInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFundingInfo)); }
+	operator LDKFundingInfo() && { LDKFundingInfo res = self; memset(&self, 0, sizeof(LDKFundingInfo)); return res; }
+	~FundingInfo() { FundingInfo_free(self); }
+	FundingInfo& operator=(FundingInfo&& o) { FundingInfo_free(self); self = o.self; memset(&o, 0, sizeof(FundingInfo)); return *this; }
+	LDKFundingInfo* operator &() { return &self; }
+	LDKFundingInfo* operator ->() { return &self; }
+	const LDKFundingInfo* operator &() const { return &self; }
+	const LDKFundingInfo* operator ->() const { return &self; }
 };
 class PaymentPurpose {
 private:
@@ -5054,6 +5966,21 @@ public:
 	 */
 	inline void process_pending_events(struct LDKEventHandler handler);
 };
+class ReplayEvent {
+private:
+	LDKReplayEvent self;
+public:
+	ReplayEvent(const ReplayEvent&) = delete;
+	ReplayEvent(ReplayEvent&& o) : self(o.self) { memset(&o, 0, sizeof(ReplayEvent)); }
+	ReplayEvent(LDKReplayEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReplayEvent)); }
+	operator LDKReplayEvent() && { LDKReplayEvent res = self; memset(&self, 0, sizeof(LDKReplayEvent)); return res; }
+	~ReplayEvent() { ReplayEvent_free(self); }
+	ReplayEvent& operator=(ReplayEvent&& o) { ReplayEvent_free(self); self = o.self; memset(&o, 0, sizeof(ReplayEvent)); return *this; }
+	LDKReplayEvent* operator &() { return &self; }
+	LDKReplayEvent* operator ->() { return &self; }
+	const LDKReplayEvent* operator &() const { return &self; }
+	const LDKReplayEvent* operator ->() const { return &self; }
+};
 class EventHandler {
 private:
 	LDKEventHandler self;
@@ -5073,7 +6000,67 @@ public:
 	 * 
 	 *  See [`EventsProvider`] for details that must be considered when implementing this method.
 	 */
-	inline void handle_event(struct LDKEvent event);
+	inline LDK::CResult_NoneReplayEventZ handle_event(struct LDKEvent event);
+};
+class Nonce {
+private:
+	LDKNonce self;
+public:
+	Nonce(const Nonce&) = delete;
+	Nonce(Nonce&& o) : self(o.self) { memset(&o, 0, sizeof(Nonce)); }
+	Nonce(LDKNonce&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNonce)); }
+	operator LDKNonce() && { LDKNonce res = self; memset(&self, 0, sizeof(LDKNonce)); return res; }
+	~Nonce() { Nonce_free(self); }
+	Nonce& operator=(Nonce&& o) { Nonce_free(self); self = o.self; memset(&o, 0, sizeof(Nonce)); return *this; }
+	LDKNonce* operator &() { return &self; }
+	LDKNonce* operator ->() { return &self; }
+	const LDKNonce* operator &() const { return &self; }
+	const LDKNonce* operator ->() const { return &self; }
+};
+class RoutingFees {
+private:
+	LDKRoutingFees self;
+public:
+	RoutingFees(const RoutingFees&) = delete;
+	RoutingFees(RoutingFees&& o) : self(o.self) { memset(&o, 0, sizeof(RoutingFees)); }
+	RoutingFees(LDKRoutingFees&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoutingFees)); }
+	operator LDKRoutingFees() && { LDKRoutingFees res = self; memset(&self, 0, sizeof(LDKRoutingFees)); return res; }
+	~RoutingFees() { RoutingFees_free(self); }
+	RoutingFees& operator=(RoutingFees&& o) { RoutingFees_free(self); self = o.self; memset(&o, 0, sizeof(RoutingFees)); return *this; }
+	LDKRoutingFees* operator &() { return &self; }
+	LDKRoutingFees* operator ->() { return &self; }
+	const LDKRoutingFees* operator &() const { return &self; }
+	const LDKRoutingFees* operator ->() const { return &self; }
+};
+class RouteHint {
+private:
+	LDKRouteHint self;
+public:
+	RouteHint(const RouteHint&) = delete;
+	RouteHint(RouteHint&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHint)); }
+	RouteHint(LDKRouteHint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHint)); }
+	operator LDKRouteHint() && { LDKRouteHint res = self; memset(&self, 0, sizeof(LDKRouteHint)); return res; }
+	~RouteHint() { RouteHint_free(self); }
+	RouteHint& operator=(RouteHint&& o) { RouteHint_free(self); self = o.self; memset(&o, 0, sizeof(RouteHint)); return *this; }
+	LDKRouteHint* operator &() { return &self; }
+	LDKRouteHint* operator ->() { return &self; }
+	const LDKRouteHint* operator &() const { return &self; }
+	const LDKRouteHint* operator ->() const { return &self; }
+};
+class RouteHintHop {
+private:
+	LDKRouteHintHop self;
+public:
+	RouteHintHop(const RouteHintHop&) = delete;
+	RouteHintHop(RouteHintHop&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHintHop)); }
+	RouteHintHop(LDKRouteHintHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHintHop)); }
+	operator LDKRouteHintHop() && { LDKRouteHintHop res = self; memset(&self, 0, sizeof(LDKRouteHintHop)); return res; }
+	~RouteHintHop() { RouteHintHop_free(self); }
+	RouteHintHop& operator=(RouteHintHop&& o) { RouteHintHop_free(self); self = o.self; memset(&o, 0, sizeof(RouteHintHop)); return *this; }
+	LDKRouteHintHop* operator &() { return &self; }
+	LDKRouteHintHop* operator ->() { return &self; }
+	const LDKRouteHintHop* operator &() const { return &self; }
+	const LDKRouteHintHop* operator ->() const { return &self; }
 };
 class Bolt11ParseError {
 private:
@@ -5431,35 +6418,20 @@ public:
 	const LDKTransactionU16LenLimited* operator &() const { return &self; }
 	const LDKTransactionU16LenLimited* operator ->() const { return &self; }
 };
-class UntrustedString {
-private:
-	LDKUntrustedString self;
-public:
-	UntrustedString(const UntrustedString&) = delete;
-	UntrustedString(UntrustedString&& o) : self(o.self) { memset(&o, 0, sizeof(UntrustedString)); }
-	UntrustedString(LDKUntrustedString&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUntrustedString)); }
-	operator LDKUntrustedString() && { LDKUntrustedString res = self; memset(&self, 0, sizeof(LDKUntrustedString)); return res; }
-	~UntrustedString() { UntrustedString_free(self); }
-	UntrustedString& operator=(UntrustedString&& o) { UntrustedString_free(self); self = o.self; memset(&o, 0, sizeof(UntrustedString)); return *this; }
-	LDKUntrustedString* operator &() { return &self; }
-	LDKUntrustedString* operator ->() { return &self; }
-	const LDKUntrustedString* operator &() const { return &self; }
-	const LDKUntrustedString* operator ->() const { return &self; }
-};
-class PrintableString {
+class ChannelId {
 private:
-	LDKPrintableString self;
+	LDKChannelId self;
 public:
-	PrintableString(const PrintableString&) = delete;
-	PrintableString(PrintableString&& o) : self(o.self) { memset(&o, 0, sizeof(PrintableString)); }
-	PrintableString(LDKPrintableString&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPrintableString)); }
-	operator LDKPrintableString() && { LDKPrintableString res = self; memset(&self, 0, sizeof(LDKPrintableString)); return res; }
-	~PrintableString() { PrintableString_free(self); }
-	PrintableString& operator=(PrintableString&& o) { PrintableString_free(self); self = o.self; memset(&o, 0, sizeof(PrintableString)); return *this; }
-	LDKPrintableString* operator &() { return &self; }
-	LDKPrintableString* operator ->() { return &self; }
-	const LDKPrintableString* operator &() const { return &self; }
-	const LDKPrintableString* operator ->() const { return &self; }
+	ChannelId(const ChannelId&) = delete;
+	ChannelId(ChannelId&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelId)); }
+	ChannelId(LDKChannelId&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelId)); }
+	operator LDKChannelId() && { LDKChannelId res = self; memset(&self, 0, sizeof(LDKChannelId)); return res; }
+	~ChannelId() { ChannelId_free(self); }
+	ChannelId& operator=(ChannelId&& o) { ChannelId_free(self); self = o.self; memset(&o, 0, sizeof(ChannelId)); return *this; }
+	LDKChannelId* operator &() { return &self; }
+	LDKChannelId* operator ->() { return &self; }
+	const LDKChannelId* operator &() const { return &self; }
+	const LDKChannelId* operator ->() const { return &self; }
 };
 class CustomMessageReader {
 private:
@@ -5506,20 +6478,50 @@ public:
 	 */
 	inline LDK::Str debug_str();
 };
-class ForwardNode {
+class BlindedPayInfo {
+private:
+	LDKBlindedPayInfo self;
+public:
+	BlindedPayInfo(const BlindedPayInfo&) = delete;
+	BlindedPayInfo(BlindedPayInfo&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedPayInfo)); }
+	BlindedPayInfo(LDKBlindedPayInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedPayInfo)); }
+	operator LDKBlindedPayInfo() && { LDKBlindedPayInfo res = self; memset(&self, 0, sizeof(LDKBlindedPayInfo)); return res; }
+	~BlindedPayInfo() { BlindedPayInfo_free(self); }
+	BlindedPayInfo& operator=(BlindedPayInfo&& o) { BlindedPayInfo_free(self); self = o.self; memset(&o, 0, sizeof(BlindedPayInfo)); return *this; }
+	LDKBlindedPayInfo* operator &() { return &self; }
+	LDKBlindedPayInfo* operator ->() { return &self; }
+	const LDKBlindedPayInfo* operator &() const { return &self; }
+	const LDKBlindedPayInfo* operator ->() const { return &self; }
+};
+class BlindedPaymentPath {
+private:
+	LDKBlindedPaymentPath self;
+public:
+	BlindedPaymentPath(const BlindedPaymentPath&) = delete;
+	BlindedPaymentPath(BlindedPaymentPath&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedPaymentPath)); }
+	BlindedPaymentPath(LDKBlindedPaymentPath&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedPaymentPath)); }
+	operator LDKBlindedPaymentPath() && { LDKBlindedPaymentPath res = self; memset(&self, 0, sizeof(LDKBlindedPaymentPath)); return res; }
+	~BlindedPaymentPath() { BlindedPaymentPath_free(self); }
+	BlindedPaymentPath& operator=(BlindedPaymentPath&& o) { BlindedPaymentPath_free(self); self = o.self; memset(&o, 0, sizeof(BlindedPaymentPath)); return *this; }
+	LDKBlindedPaymentPath* operator &() { return &self; }
+	LDKBlindedPaymentPath* operator ->() { return &self; }
+	const LDKBlindedPaymentPath* operator &() const { return &self; }
+	const LDKBlindedPaymentPath* operator ->() const { return &self; }
+};
+class PaymentForwardNode {
 private:
-	LDKForwardNode self;
+	LDKPaymentForwardNode self;
 public:
-	ForwardNode(const ForwardNode&) = delete;
-	ForwardNode(ForwardNode&& o) : self(o.self) { memset(&o, 0, sizeof(ForwardNode)); }
-	ForwardNode(LDKForwardNode&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKForwardNode)); }
-	operator LDKForwardNode() && { LDKForwardNode res = self; memset(&self, 0, sizeof(LDKForwardNode)); return res; }
-	~ForwardNode() { ForwardNode_free(self); }
-	ForwardNode& operator=(ForwardNode&& o) { ForwardNode_free(self); self = o.self; memset(&o, 0, sizeof(ForwardNode)); return *this; }
-	LDKForwardNode* operator &() { return &self; }
-	LDKForwardNode* operator ->() { return &self; }
-	const LDKForwardNode* operator &() const { return &self; }
-	const LDKForwardNode* operator ->() const { return &self; }
+	PaymentForwardNode(const PaymentForwardNode&) = delete;
+	PaymentForwardNode(PaymentForwardNode&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentForwardNode)); }
+	PaymentForwardNode(LDKPaymentForwardNode&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentForwardNode)); }
+	operator LDKPaymentForwardNode() && { LDKPaymentForwardNode res = self; memset(&self, 0, sizeof(LDKPaymentForwardNode)); return res; }
+	~PaymentForwardNode() { PaymentForwardNode_free(self); }
+	PaymentForwardNode& operator=(PaymentForwardNode&& o) { PaymentForwardNode_free(self); self = o.self; memset(&o, 0, sizeof(PaymentForwardNode)); return *this; }
+	LDKPaymentForwardNode* operator &() { return &self; }
+	LDKPaymentForwardNode* operator ->() { return &self; }
+	const LDKPaymentForwardNode* operator &() const { return &self; }
+	const LDKPaymentForwardNode* operator ->() const { return &self; }
 };
 class ForwardTlvs {
 private:
@@ -5581,35 +6583,65 @@ public:
 	const LDKPaymentConstraints* operator &() const { return &self; }
 	const LDKPaymentConstraints* 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 ProbingError {
-private:
-	LDKProbingError self;
-public:
-	ProbingError(const ProbingError&) = delete;
-	ProbingError(ProbingError&& o) : self(o.self) { memset(&o, 0, sizeof(ProbingError)); }
-	ProbingError(LDKProbingError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKProbingError)); }
-	operator LDKProbingError() && { LDKProbingError res = self; memset(&self, 0, sizeof(LDKProbingError)); return res; }
-	~ProbingError() { ProbingError_free(self); }
-	ProbingError& operator=(ProbingError&& o) { ProbingError_free(self); self = o.self; memset(&o, 0, sizeof(ProbingError)); return *this; }
-	LDKProbingError* operator &() { return &self; }
-	LDKProbingError* operator ->() { return &self; }
-	const LDKProbingError* operator &() const { return &self; }
-	const LDKProbingError* operator ->() const { return &self; }
+class PaymentContext {
+private:
+	LDKPaymentContext self;
+public:
+	PaymentContext(const PaymentContext&) = delete;
+	PaymentContext(PaymentContext&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentContext)); }
+	PaymentContext(LDKPaymentContext&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentContext)); }
+	operator LDKPaymentContext() && { LDKPaymentContext res = self; memset(&self, 0, sizeof(LDKPaymentContext)); return res; }
+	~PaymentContext() { PaymentContext_free(self); }
+	PaymentContext& operator=(PaymentContext&& o) { PaymentContext_free(self); self = o.self; memset(&o, 0, sizeof(PaymentContext)); return *this; }
+	LDKPaymentContext* operator &() { return &self; }
+	LDKPaymentContext* operator ->() { return &self; }
+	const LDKPaymentContext* operator &() const { return &self; }
+	const LDKPaymentContext* operator ->() const { return &self; }
+};
+class UnknownPaymentContext {
+private:
+	LDKUnknownPaymentContext self;
+public:
+	UnknownPaymentContext(const UnknownPaymentContext&) = delete;
+	UnknownPaymentContext(UnknownPaymentContext&& o) : self(o.self) { memset(&o, 0, sizeof(UnknownPaymentContext)); }
+	UnknownPaymentContext(LDKUnknownPaymentContext&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnknownPaymentContext)); }
+	operator LDKUnknownPaymentContext() && { LDKUnknownPaymentContext res = self; memset(&self, 0, sizeof(LDKUnknownPaymentContext)); return res; }
+	~UnknownPaymentContext() { UnknownPaymentContext_free(self); }
+	UnknownPaymentContext& operator=(UnknownPaymentContext&& o) { UnknownPaymentContext_free(self); self = o.self; memset(&o, 0, sizeof(UnknownPaymentContext)); return *this; }
+	LDKUnknownPaymentContext* operator &() { return &self; }
+	LDKUnknownPaymentContext* operator ->() { return &self; }
+	const LDKUnknownPaymentContext* operator &() const { return &self; }
+	const LDKUnknownPaymentContext* operator ->() const { return &self; }
+};
+class Bolt12OfferContext {
+private:
+	LDKBolt12OfferContext self;
+public:
+	Bolt12OfferContext(const Bolt12OfferContext&) = delete;
+	Bolt12OfferContext(Bolt12OfferContext&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt12OfferContext)); }
+	Bolt12OfferContext(LDKBolt12OfferContext&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt12OfferContext)); }
+	operator LDKBolt12OfferContext() && { LDKBolt12OfferContext res = self; memset(&self, 0, sizeof(LDKBolt12OfferContext)); return res; }
+	~Bolt12OfferContext() { Bolt12OfferContext_free(self); }
+	Bolt12OfferContext& operator=(Bolt12OfferContext&& o) { Bolt12OfferContext_free(self); self = o.self; memset(&o, 0, sizeof(Bolt12OfferContext)); return *this; }
+	LDKBolt12OfferContext* operator &() { return &self; }
+	LDKBolt12OfferContext* operator ->() { return &self; }
+	const LDKBolt12OfferContext* operator &() const { return &self; }
+	const LDKBolt12OfferContext* operator ->() const { return &self; }
+};
+class Bolt12RefundContext {
+private:
+	LDKBolt12RefundContext self;
+public:
+	Bolt12RefundContext(const Bolt12RefundContext&) = delete;
+	Bolt12RefundContext(Bolt12RefundContext&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt12RefundContext)); }
+	Bolt12RefundContext(LDKBolt12RefundContext&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt12RefundContext)); }
+	operator LDKBolt12RefundContext() && { LDKBolt12RefundContext res = self; memset(&self, 0, sizeof(LDKBolt12RefundContext)); return res; }
+	~Bolt12RefundContext() { Bolt12RefundContext_free(self); }
+	Bolt12RefundContext& operator=(Bolt12RefundContext&& o) { Bolt12RefundContext_free(self); self = o.self; memset(&o, 0, sizeof(Bolt12RefundContext)); return *this; }
+	LDKBolt12RefundContext* operator &() { return &self; }
+	LDKBolt12RefundContext* operator ->() { return &self; }
+	const LDKBolt12RefundContext* operator &() const { return &self; }
+	const LDKBolt12RefundContext* operator ->() const { return &self; }
 };
 class UtxoLookupError {
 private:
@@ -5693,6 +6725,51 @@ public:
 	const LDKOnionMessenger* operator &() const { return &self; }
 	const LDKOnionMessenger* operator ->() const { return &self; }
 };
+class Responder {
+private:
+	LDKResponder self;
+public:
+	Responder(const Responder&) = delete;
+	Responder(Responder&& o) : self(o.self) { memset(&o, 0, sizeof(Responder)); }
+	Responder(LDKResponder&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKResponder)); }
+	operator LDKResponder() && { LDKResponder res = self; memset(&self, 0, sizeof(LDKResponder)); return res; }
+	~Responder() { Responder_free(self); }
+	Responder& operator=(Responder&& o) { Responder_free(self); self = o.self; memset(&o, 0, sizeof(Responder)); return *this; }
+	LDKResponder* operator &() { return &self; }
+	LDKResponder* operator ->() { return &self; }
+	const LDKResponder* operator &() const { return &self; }
+	const LDKResponder* operator ->() const { return &self; }
+};
+class ResponseInstruction {
+private:
+	LDKResponseInstruction self;
+public:
+	ResponseInstruction(const ResponseInstruction&) = delete;
+	ResponseInstruction(ResponseInstruction&& o) : self(o.self) { memset(&o, 0, sizeof(ResponseInstruction)); }
+	ResponseInstruction(LDKResponseInstruction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKResponseInstruction)); }
+	operator LDKResponseInstruction() && { LDKResponseInstruction res = self; memset(&self, 0, sizeof(LDKResponseInstruction)); return res; }
+	~ResponseInstruction() { ResponseInstruction_free(self); }
+	ResponseInstruction& operator=(ResponseInstruction&& o) { ResponseInstruction_free(self); self = o.self; memset(&o, 0, sizeof(ResponseInstruction)); return *this; }
+	LDKResponseInstruction* operator &() { return &self; }
+	LDKResponseInstruction* operator ->() { return &self; }
+	const LDKResponseInstruction* operator &() const { return &self; }
+	const LDKResponseInstruction* operator ->() const { return &self; }
+};
+class MessageSendInstructions {
+private:
+	LDKMessageSendInstructions self;
+public:
+	MessageSendInstructions(const MessageSendInstructions&) = delete;
+	MessageSendInstructions(MessageSendInstructions&& o) : self(o.self) { memset(&o, 0, sizeof(MessageSendInstructions)); }
+	MessageSendInstructions(LDKMessageSendInstructions&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageSendInstructions)); }
+	operator LDKMessageSendInstructions() && { LDKMessageSendInstructions res = self; memset(&self, 0, sizeof(LDKMessageSendInstructions)); return res; }
+	~MessageSendInstructions() { MessageSendInstructions_free(self); }
+	MessageSendInstructions& operator=(MessageSendInstructions&& o) { MessageSendInstructions_free(self); self = o.self; memset(&o, 0, sizeof(MessageSendInstructions)); return *this; }
+	LDKMessageSendInstructions* operator &() { return &self; }
+	LDKMessageSendInstructions* operator ->() { return &self; }
+	const LDKMessageSendInstructions* operator &() const { return &self; }
+	const LDKMessageSendInstructions* operator ->() const { return &self; }
+};
 class MessageRouter {
 private:
 	LDKMessageRouter self;
@@ -5711,6 +6788,27 @@ public:
 	 *  Returns a route for sending an [`OnionMessage`] to the given [`Destination`].
 	 */
 	inline LDK::CResult_OnionMessagePathNoneZ find_path(struct LDKPublicKey sender, struct LDKCVec_PublicKeyZ peers, struct LDKDestination destination);
+	/**
+	 *  Creates [`BlindedMessagePath`]s to the `recipient` node. The nodes in `peers` are assumed to
+	 *  be direct peers with the `recipient`.
+	 */
+	inline LDK::CResult_CVec_BlindedMessagePathZNoneZ create_blinded_paths(struct LDKPublicKey recipient, struct LDKMessageContext context, struct LDKCVec_PublicKeyZ peers);
+	/**
+	 *  Creates compact [`BlindedMessagePath`]s to the `recipient` node. The nodes in `peers` are
+	 *  assumed to be direct peers with the `recipient`.
+	 * 
+	 *  Compact blinded paths use short channel ids instead of pubkeys for a smaller serialization,
+	 *  which is beneficial when a QR code is used to transport the data. The SCID is passed using
+	 *  a [`MessageForwardNode`] but may be `None` for graceful degradation.
+	 * 
+	 *  Implementations using additional intermediate nodes are responsible for using a
+	 *  [`MessageForwardNode`] with `Some` short channel id, if possible. Similarly, implementations
+	 *  should call [`BlindedMessagePath::use_compact_introduction_node`].
+	 * 
+	 *  The provided implementation simply delegates to [`MessageRouter::create_blinded_paths`],
+	 *  ignoring the short channel ids.
+	 */
+	inline LDK::CResult_CVec_BlindedMessagePathZNoneZ create_compact_blinded_paths(struct LDKPublicKey recipient, struct LDKMessageContext context, struct LDKCVec_MessageForwardNodeZ peers);
 };
 class DefaultMessageRouter {
 private:
@@ -5757,6 +6855,21 @@ public:
 	const LDKDestination* operator &() const { return &self; }
 	const LDKDestination* operator ->() const { return &self; }
 };
+class SendSuccess {
+private:
+	LDKSendSuccess self;
+public:
+	SendSuccess(const SendSuccess&) = delete;
+	SendSuccess(SendSuccess&& o) : self(o.self) { memset(&o, 0, sizeof(SendSuccess)); }
+	SendSuccess(LDKSendSuccess&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSendSuccess)); }
+	operator LDKSendSuccess() && { LDKSendSuccess res = self; memset(&self, 0, sizeof(LDKSendSuccess)); return res; }
+	~SendSuccess() { SendSuccess_free(self); }
+	SendSuccess& operator=(SendSuccess&& o) { SendSuccess_free(self); self = o.self; memset(&o, 0, sizeof(SendSuccess)); return *this; }
+	LDKSendSuccess* operator &() { return &self; }
+	LDKSendSuccess* operator ->() { return &self; }
+	const LDKSendSuccess* operator &() const { return &self; }
+	const LDKSendSuccess* operator ->() const { return &self; }
+};
 class SendError {
 private:
 	LDKSendError self;
@@ -5790,8 +6903,10 @@ public:
 	 *  Called with the custom message that was received, returning a response to send, if any.
 	 * 
 	 *  The returned [`Self::CustomMessage`], if any, is enqueued to be sent by [`OnionMessenger`].
+	 * 
+	 *  Note that responder (or a relevant inner pointer) may be NULL or all-0s to represent None
 	 */
-	inline LDK::COption_OnionMessageContentsZ handle_custom_message(struct LDKOnionMessageContents msg);
+	inline LDK::COption_C2Tuple_OnionMessageContentsResponseInstructionZZ handle_custom_message(struct LDKOnionMessageContents message, struct LDKCOption_CVec_u8ZZ context, struct LDKResponder responder);
 	/**
 	 *  Read a custom message of type `message_type` from `buffer`, returning `Ok(None)` if the
 	 *  message type is unknown.
@@ -5803,7 +6918,7 @@ public:
 	 *  Typically, this is used for messages initiating a message flow rather than in response to
 	 *  another message. The latter should use the return value of [`Self::handle_custom_message`].
 	 */
-	inline LDK::CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ release_pending_custom_messages();
+	inline LDK::CVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ release_pending_custom_messages();
 };
 class PeeledOnion {
 private:
@@ -5835,50 +6950,225 @@ public:
 	const LDKFilesystemStore* operator &() const { return &self; }
 	const LDKFilesystemStore* operator ->() const { return &self; }
 };
-class BlindedPath {
+class InitFeatures {
 private:
-	LDKBlindedPath self;
+	LDKInitFeatures self;
 public:
-	BlindedPath(const BlindedPath&) = delete;
-	BlindedPath(BlindedPath&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedPath)); }
-	BlindedPath(LDKBlindedPath&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedPath)); }
-	operator LDKBlindedPath() && { LDKBlindedPath res = self; memset(&self, 0, sizeof(LDKBlindedPath)); return res; }
-	~BlindedPath() { BlindedPath_free(self); }
-	BlindedPath& operator=(BlindedPath&& o) { BlindedPath_free(self); self = o.self; memset(&o, 0, sizeof(BlindedPath)); return *this; }
-	LDKBlindedPath* operator &() { return &self; }
-	LDKBlindedPath* operator ->() { return &self; }
-	const LDKBlindedPath* operator &() const { return &self; }
-	const LDKBlindedPath* operator ->() const { return &self; }
+	InitFeatures(const InitFeatures&) = delete;
+	InitFeatures(InitFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(InitFeatures)); }
+	InitFeatures(LDKInitFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInitFeatures)); }
+	operator LDKInitFeatures() && { LDKInitFeatures res = self; memset(&self, 0, sizeof(LDKInitFeatures)); return res; }
+	~InitFeatures() { InitFeatures_free(self); }
+	InitFeatures& operator=(InitFeatures&& o) { InitFeatures_free(self); self = o.self; memset(&o, 0, sizeof(InitFeatures)); return *this; }
+	LDKInitFeatures* operator &() { return &self; }
+	LDKInitFeatures* operator ->() { return &self; }
+	const LDKInitFeatures* operator &() const { return &self; }
+	const LDKInitFeatures* operator ->() const { return &self; }
 };
-class BlindedHop {
+class NodeFeatures {
 private:
-	LDKBlindedHop self;
+	LDKNodeFeatures self;
 public:
-	BlindedHop(const BlindedHop&) = delete;
-	BlindedHop(BlindedHop&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedHop)); }
-	BlindedHop(LDKBlindedHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedHop)); }
-	operator LDKBlindedHop() && { LDKBlindedHop res = self; memset(&self, 0, sizeof(LDKBlindedHop)); return res; }
-	~BlindedHop() { BlindedHop_free(self); }
-	BlindedHop& operator=(BlindedHop&& o) { BlindedHop_free(self); self = o.self; memset(&o, 0, sizeof(BlindedHop)); return *this; }
-	LDKBlindedHop* operator &() { return &self; }
-	LDKBlindedHop* operator ->() { return &self; }
-	const LDKBlindedHop* operator &() const { return &self; }
-	const LDKBlindedHop* operator ->() const { return &self; }
+	NodeFeatures(const NodeFeatures&) = delete;
+	NodeFeatures(NodeFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(NodeFeatures)); }
+	NodeFeatures(LDKNodeFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeFeatures)); }
+	operator LDKNodeFeatures() && { LDKNodeFeatures res = self; memset(&self, 0, sizeof(LDKNodeFeatures)); return res; }
+	~NodeFeatures() { NodeFeatures_free(self); }
+	NodeFeatures& operator=(NodeFeatures&& o) { NodeFeatures_free(self); self = o.self; memset(&o, 0, sizeof(NodeFeatures)); return *this; }
+	LDKNodeFeatures* operator &() { return &self; }
+	LDKNodeFeatures* operator ->() { return &self; }
+	const LDKNodeFeatures* operator &() const { return &self; }
+	const LDKNodeFeatures* operator ->() const { return &self; }
 };
-class GraphSyncError {
+class ChannelFeatures {
 private:
-	LDKGraphSyncError self;
+	LDKChannelFeatures self;
 public:
-	GraphSyncError(const GraphSyncError&) = delete;
-	GraphSyncError(GraphSyncError&& o) : self(o.self) { memset(&o, 0, sizeof(GraphSyncError)); }
-	GraphSyncError(LDKGraphSyncError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKGraphSyncError)); }
-	operator LDKGraphSyncError() && { LDKGraphSyncError res = self; memset(&self, 0, sizeof(LDKGraphSyncError)); return res; }
-	~GraphSyncError() { GraphSyncError_free(self); }
-	GraphSyncError& operator=(GraphSyncError&& o) { GraphSyncError_free(self); self = o.self; memset(&o, 0, sizeof(GraphSyncError)); return *this; }
-	LDKGraphSyncError* operator &() { return &self; }
-	LDKGraphSyncError* operator ->() { return &self; }
-	const LDKGraphSyncError* operator &() const { return &self; }
-	const LDKGraphSyncError* operator ->() const { return &self; }
+	ChannelFeatures(const ChannelFeatures&) = delete;
+	ChannelFeatures(ChannelFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelFeatures)); }
+	ChannelFeatures(LDKChannelFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelFeatures)); }
+	operator LDKChannelFeatures() && { LDKChannelFeatures res = self; memset(&self, 0, sizeof(LDKChannelFeatures)); return res; }
+	~ChannelFeatures() { ChannelFeatures_free(self); }
+	ChannelFeatures& operator=(ChannelFeatures&& o) { ChannelFeatures_free(self); self = o.self; memset(&o, 0, sizeof(ChannelFeatures)); return *this; }
+	LDKChannelFeatures* operator &() { return &self; }
+	LDKChannelFeatures* operator ->() { return &self; }
+	const LDKChannelFeatures* operator &() const { return &self; }
+	const LDKChannelFeatures* operator ->() const { return &self; }
+};
+class Bolt11InvoiceFeatures {
+private:
+	LDKBolt11InvoiceFeatures self;
+public:
+	Bolt11InvoiceFeatures(const Bolt11InvoiceFeatures&) = delete;
+	Bolt11InvoiceFeatures(Bolt11InvoiceFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt11InvoiceFeatures)); }
+	Bolt11InvoiceFeatures(LDKBolt11InvoiceFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt11InvoiceFeatures)); }
+	operator LDKBolt11InvoiceFeatures() && { LDKBolt11InvoiceFeatures res = self; memset(&self, 0, sizeof(LDKBolt11InvoiceFeatures)); return res; }
+	~Bolt11InvoiceFeatures() { Bolt11InvoiceFeatures_free(self); }
+	Bolt11InvoiceFeatures& operator=(Bolt11InvoiceFeatures&& o) { Bolt11InvoiceFeatures_free(self); self = o.self; memset(&o, 0, sizeof(Bolt11InvoiceFeatures)); return *this; }
+	LDKBolt11InvoiceFeatures* operator &() { return &self; }
+	LDKBolt11InvoiceFeatures* operator ->() { return &self; }
+	const LDKBolt11InvoiceFeatures* operator &() const { return &self; }
+	const LDKBolt11InvoiceFeatures* operator ->() const { return &self; }
+};
+class OfferFeatures {
+private:
+	LDKOfferFeatures self;
+public:
+	OfferFeatures(const OfferFeatures&) = delete;
+	OfferFeatures(OfferFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(OfferFeatures)); }
+	OfferFeatures(LDKOfferFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOfferFeatures)); }
+	operator LDKOfferFeatures() && { LDKOfferFeatures res = self; memset(&self, 0, sizeof(LDKOfferFeatures)); return res; }
+	~OfferFeatures() { OfferFeatures_free(self); }
+	OfferFeatures& operator=(OfferFeatures&& o) { OfferFeatures_free(self); self = o.self; memset(&o, 0, sizeof(OfferFeatures)); return *this; }
+	LDKOfferFeatures* operator &() { return &self; }
+	LDKOfferFeatures* operator ->() { return &self; }
+	const LDKOfferFeatures* operator &() const { return &self; }
+	const LDKOfferFeatures* operator ->() const { return &self; }
+};
+class InvoiceRequestFeatures {
+private:
+	LDKInvoiceRequestFeatures self;
+public:
+	InvoiceRequestFeatures(const InvoiceRequestFeatures&) = delete;
+	InvoiceRequestFeatures(InvoiceRequestFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceRequestFeatures)); }
+	InvoiceRequestFeatures(LDKInvoiceRequestFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceRequestFeatures)); }
+	operator LDKInvoiceRequestFeatures() && { LDKInvoiceRequestFeatures res = self; memset(&self, 0, sizeof(LDKInvoiceRequestFeatures)); return res; }
+	~InvoiceRequestFeatures() { InvoiceRequestFeatures_free(self); }
+	InvoiceRequestFeatures& operator=(InvoiceRequestFeatures&& o) { InvoiceRequestFeatures_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceRequestFeatures)); return *this; }
+	LDKInvoiceRequestFeatures* operator &() { return &self; }
+	LDKInvoiceRequestFeatures* operator ->() { return &self; }
+	const LDKInvoiceRequestFeatures* operator &() const { return &self; }
+	const LDKInvoiceRequestFeatures* operator ->() const { return &self; }
+};
+class Bolt12InvoiceFeatures {
+private:
+	LDKBolt12InvoiceFeatures self;
+public:
+	Bolt12InvoiceFeatures(const Bolt12InvoiceFeatures&) = delete;
+	Bolt12InvoiceFeatures(Bolt12InvoiceFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt12InvoiceFeatures)); }
+	Bolt12InvoiceFeatures(LDKBolt12InvoiceFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt12InvoiceFeatures)); }
+	operator LDKBolt12InvoiceFeatures() && { LDKBolt12InvoiceFeatures res = self; memset(&self, 0, sizeof(LDKBolt12InvoiceFeatures)); return res; }
+	~Bolt12InvoiceFeatures() { Bolt12InvoiceFeatures_free(self); }
+	Bolt12InvoiceFeatures& operator=(Bolt12InvoiceFeatures&& o) { Bolt12InvoiceFeatures_free(self); self = o.self; memset(&o, 0, sizeof(Bolt12InvoiceFeatures)); return *this; }
+	LDKBolt12InvoiceFeatures* operator &() { return &self; }
+	LDKBolt12InvoiceFeatures* operator ->() { return &self; }
+	const LDKBolt12InvoiceFeatures* operator &() const { return &self; }
+	const LDKBolt12InvoiceFeatures* operator ->() const { return &self; }
+};
+class BlindedHopFeatures {
+private:
+	LDKBlindedHopFeatures self;
+public:
+	BlindedHopFeatures(const BlindedHopFeatures&) = delete;
+	BlindedHopFeatures(BlindedHopFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedHopFeatures)); }
+	BlindedHopFeatures(LDKBlindedHopFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedHopFeatures)); }
+	operator LDKBlindedHopFeatures() && { LDKBlindedHopFeatures res = self; memset(&self, 0, sizeof(LDKBlindedHopFeatures)); return res; }
+	~BlindedHopFeatures() { BlindedHopFeatures_free(self); }
+	BlindedHopFeatures& operator=(BlindedHopFeatures&& o) { BlindedHopFeatures_free(self); self = o.self; memset(&o, 0, sizeof(BlindedHopFeatures)); return *this; }
+	LDKBlindedHopFeatures* operator &() { return &self; }
+	LDKBlindedHopFeatures* operator ->() { return &self; }
+	const LDKBlindedHopFeatures* operator &() const { return &self; }
+	const LDKBlindedHopFeatures* operator ->() const { return &self; }
+};
+class ChannelTypeFeatures {
+private:
+	LDKChannelTypeFeatures self;
+public:
+	ChannelTypeFeatures(const ChannelTypeFeatures&) = delete;
+	ChannelTypeFeatures(ChannelTypeFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelTypeFeatures)); }
+	ChannelTypeFeatures(LDKChannelTypeFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelTypeFeatures)); }
+	operator LDKChannelTypeFeatures() && { LDKChannelTypeFeatures res = self; memset(&self, 0, sizeof(LDKChannelTypeFeatures)); return res; }
+	~ChannelTypeFeatures() { ChannelTypeFeatures_free(self); }
+	ChannelTypeFeatures& operator=(ChannelTypeFeatures&& o) { ChannelTypeFeatures_free(self); self = o.self; memset(&o, 0, sizeof(ChannelTypeFeatures)); return *this; }
+	LDKChannelTypeFeatures* operator &() { return &self; }
+	LDKChannelTypeFeatures* operator ->() { return &self; }
+	const LDKChannelTypeFeatures* operator &() const { return &self; }
+	const LDKChannelTypeFeatures* operator ->() const { return &self; }
+};
+class IntroductionNode {
+private:
+	LDKIntroductionNode self;
+public:
+	IntroductionNode(const IntroductionNode&) = delete;
+	IntroductionNode(IntroductionNode&& o) : self(o.self) { memset(&o, 0, sizeof(IntroductionNode)); }
+	IntroductionNode(LDKIntroductionNode&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKIntroductionNode)); }
+	operator LDKIntroductionNode() && { LDKIntroductionNode res = self; memset(&self, 0, sizeof(LDKIntroductionNode)); return res; }
+	~IntroductionNode() { IntroductionNode_free(self); }
+	IntroductionNode& operator=(IntroductionNode&& o) { IntroductionNode_free(self); self = o.self; memset(&o, 0, sizeof(IntroductionNode)); return *this; }
+	LDKIntroductionNode* operator &() { return &self; }
+	LDKIntroductionNode* operator ->() { return &self; }
+	const LDKIntroductionNode* operator &() const { return &self; }
+	const LDKIntroductionNode* operator ->() const { return &self; }
+};
+class Direction {
+private:
+	LDKDirection self;
+public:
+	Direction(const Direction&) = delete;
+	Direction(Direction&& o) : self(o.self) { memset(&o, 0, sizeof(Direction)); }
+	Direction(LDKDirection&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDirection)); }
+	operator LDKDirection() && { LDKDirection res = self; memset(&self, 0, sizeof(LDKDirection)); return res; }
+	Direction& operator=(Direction&& o) { self = o.self; memset(&o, 0, sizeof(Direction)); return *this; }
+	LDKDirection* operator &() { return &self; }
+	LDKDirection* operator ->() { return &self; }
+	const LDKDirection* operator &() const { return &self; }
+	const LDKDirection* operator ->() const { return &self; }
+};
+class NodeIdLookUp {
+private:
+	LDKNodeIdLookUp self;
+public:
+	NodeIdLookUp(const NodeIdLookUp&) = delete;
+	NodeIdLookUp(NodeIdLookUp&& o) : self(o.self) { memset(&o, 0, sizeof(NodeIdLookUp)); }
+	NodeIdLookUp(LDKNodeIdLookUp&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeIdLookUp)); }
+	operator LDKNodeIdLookUp() && { LDKNodeIdLookUp res = self; memset(&self, 0, sizeof(LDKNodeIdLookUp)); return res; }
+	~NodeIdLookUp() { NodeIdLookUp_free(self); }
+	NodeIdLookUp& operator=(NodeIdLookUp&& o) { NodeIdLookUp_free(self); self = o.self; memset(&o, 0, sizeof(NodeIdLookUp)); return *this; }
+	LDKNodeIdLookUp* operator &() { return &self; }
+	LDKNodeIdLookUp* operator ->() { return &self; }
+	const LDKNodeIdLookUp* operator &() const { return &self; }
+	const LDKNodeIdLookUp* operator ->() const { return &self; }
+	/**
+	 *  Returns the node id of the forwarding node's channel counterparty with `short_channel_id`.
+	 * 
+	 *  Here, the forwarding node is referring to the node of the [`OnionMessenger`] parameterized
+	 *  by the [`NodeIdLookUp`] and the counterparty to one of that node's peers.
+	 * 
+	 *  [`OnionMessenger`]: crate::onion_message::messenger::OnionMessenger
+	 * 
+	 *  Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
+	 */
+	inline LDKPublicKey next_node_id(uint64_t short_channel_id);
+};
+class EmptyNodeIdLookUp {
+private:
+	LDKEmptyNodeIdLookUp self;
+public:
+	EmptyNodeIdLookUp(const EmptyNodeIdLookUp&) = delete;
+	EmptyNodeIdLookUp(EmptyNodeIdLookUp&& o) : self(o.self) { memset(&o, 0, sizeof(EmptyNodeIdLookUp)); }
+	EmptyNodeIdLookUp(LDKEmptyNodeIdLookUp&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEmptyNodeIdLookUp)); }
+	operator LDKEmptyNodeIdLookUp() && { LDKEmptyNodeIdLookUp res = self; memset(&self, 0, sizeof(LDKEmptyNodeIdLookUp)); return res; }
+	~EmptyNodeIdLookUp() { EmptyNodeIdLookUp_free(self); }
+	EmptyNodeIdLookUp& operator=(EmptyNodeIdLookUp&& o) { EmptyNodeIdLookUp_free(self); self = o.self; memset(&o, 0, sizeof(EmptyNodeIdLookUp)); return *this; }
+	LDKEmptyNodeIdLookUp* operator &() { return &self; }
+	LDKEmptyNodeIdLookUp* operator ->() { return &self; }
+	const LDKEmptyNodeIdLookUp* operator &() const { return &self; }
+	const LDKEmptyNodeIdLookUp* operator ->() const { return &self; }
+};
+class BlindedHop {
+private:
+	LDKBlindedHop self;
+public:
+	BlindedHop(const BlindedHop&) = delete;
+	BlindedHop(BlindedHop&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedHop)); }
+	BlindedHop(LDKBlindedHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedHop)); }
+	operator LDKBlindedHop() && { LDKBlindedHop res = self; memset(&self, 0, sizeof(LDKBlindedHop)); return res; }
+	~BlindedHop() { BlindedHop_free(self); }
+	BlindedHop& operator=(BlindedHop&& o) { BlindedHop_free(self); self = o.self; memset(&o, 0, sizeof(BlindedHop)); return *this; }
+	LDKBlindedHop* operator &() { return &self; }
+	LDKBlindedHop* operator ->() { return &self; }
+	const LDKBlindedHop* operator &() const { return &self; }
+	const LDKBlindedHop* operator ->() const { return &self; }
 };
 class InvoiceError {
 private:
@@ -5910,20 +7200,155 @@ public:
 	const LDKErroneousField* operator &() const { return &self; }
 	const LDKErroneousField* operator ->() const { return &self; }
 };
-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 TrackedSpendableOutput {
+private:
+	LDKTrackedSpendableOutput self;
+public:
+	TrackedSpendableOutput(const TrackedSpendableOutput&) = delete;
+	TrackedSpendableOutput(TrackedSpendableOutput&& o) : self(o.self) { memset(&o, 0, sizeof(TrackedSpendableOutput)); }
+	TrackedSpendableOutput(LDKTrackedSpendableOutput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTrackedSpendableOutput)); }
+	operator LDKTrackedSpendableOutput() && { LDKTrackedSpendableOutput res = self; memset(&self, 0, sizeof(LDKTrackedSpendableOutput)); return res; }
+	~TrackedSpendableOutput() { TrackedSpendableOutput_free(self); }
+	TrackedSpendableOutput& operator=(TrackedSpendableOutput&& o) { TrackedSpendableOutput_free(self); self = o.self; memset(&o, 0, sizeof(TrackedSpendableOutput)); return *this; }
+	LDKTrackedSpendableOutput* operator &() { return &self; }
+	LDKTrackedSpendableOutput* operator ->() { return &self; }
+	const LDKTrackedSpendableOutput* operator &() const { return &self; }
+	const LDKTrackedSpendableOutput* operator ->() const { return &self; }
+};
+class OutputSpendStatus {
+private:
+	LDKOutputSpendStatus self;
+public:
+	OutputSpendStatus(const OutputSpendStatus&) = delete;
+	OutputSpendStatus(OutputSpendStatus&& o) : self(o.self) { memset(&o, 0, sizeof(OutputSpendStatus)); }
+	OutputSpendStatus(LDKOutputSpendStatus&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOutputSpendStatus)); }
+	operator LDKOutputSpendStatus() && { LDKOutputSpendStatus res = self; memset(&self, 0, sizeof(LDKOutputSpendStatus)); return res; }
+	~OutputSpendStatus() { OutputSpendStatus_free(self); }
+	OutputSpendStatus& operator=(OutputSpendStatus&& o) { OutputSpendStatus_free(self); self = o.self; memset(&o, 0, sizeof(OutputSpendStatus)); return *this; }
+	LDKOutputSpendStatus* operator &() { return &self; }
+	LDKOutputSpendStatus* operator ->() { return &self; }
+	const LDKOutputSpendStatus* operator &() const { return &self; }
+	const LDKOutputSpendStatus* operator ->() const { return &self; }
+};
+class OutputSweeper {
+private:
+	LDKOutputSweeper self;
+public:
+	OutputSweeper(const OutputSweeper&) = delete;
+	OutputSweeper(OutputSweeper&& o) : self(o.self) { memset(&o, 0, sizeof(OutputSweeper)); }
+	OutputSweeper(LDKOutputSweeper&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOutputSweeper)); }
+	operator LDKOutputSweeper() && { LDKOutputSweeper res = self; memset(&self, 0, sizeof(LDKOutputSweeper)); return res; }
+	~OutputSweeper() { OutputSweeper_free(self); }
+	OutputSweeper& operator=(OutputSweeper&& o) { OutputSweeper_free(self); self = o.self; memset(&o, 0, sizeof(OutputSweeper)); return *this; }
+	LDKOutputSweeper* operator &() { return &self; }
+	LDKOutputSweeper* operator ->() { return &self; }
+	const LDKOutputSweeper* operator &() const { return &self; }
+	const LDKOutputSweeper* operator ->() const { return &self; }
+};
+class SpendingDelay {
+private:
+	LDKSpendingDelay self;
+public:
+	SpendingDelay(const SpendingDelay&) = delete;
+	SpendingDelay(SpendingDelay&& o) : self(o.self) { memset(&o, 0, sizeof(SpendingDelay)); }
+	SpendingDelay(LDKSpendingDelay&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSpendingDelay)); }
+	operator LDKSpendingDelay() && { LDKSpendingDelay res = self; memset(&self, 0, sizeof(LDKSpendingDelay)); return res; }
+	~SpendingDelay() { SpendingDelay_free(self); }
+	SpendingDelay& operator=(SpendingDelay&& o) { SpendingDelay_free(self); self = o.self; memset(&o, 0, sizeof(SpendingDelay)); return *this; }
+	LDKSpendingDelay* operator &() { return &self; }
+	LDKSpendingDelay* operator ->() { return &self; }
+	const LDKSpendingDelay* operator &() const { return &self; }
+	const LDKSpendingDelay* operator ->() const { return &self; }
+};
+class DelayedPaymentBasepoint {
+private:
+	LDKDelayedPaymentBasepoint self;
+public:
+	DelayedPaymentBasepoint(const DelayedPaymentBasepoint&) = delete;
+	DelayedPaymentBasepoint(DelayedPaymentBasepoint&& o) : self(o.self) { memset(&o, 0, sizeof(DelayedPaymentBasepoint)); }
+	DelayedPaymentBasepoint(LDKDelayedPaymentBasepoint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDelayedPaymentBasepoint)); }
+	operator LDKDelayedPaymentBasepoint() && { LDKDelayedPaymentBasepoint res = self; memset(&self, 0, sizeof(LDKDelayedPaymentBasepoint)); return res; }
+	~DelayedPaymentBasepoint() { DelayedPaymentBasepoint_free(self); }
+	DelayedPaymentBasepoint& operator=(DelayedPaymentBasepoint&& o) { DelayedPaymentBasepoint_free(self); self = o.self; memset(&o, 0, sizeof(DelayedPaymentBasepoint)); return *this; }
+	LDKDelayedPaymentBasepoint* operator &() { return &self; }
+	LDKDelayedPaymentBasepoint* operator ->() { return &self; }
+	const LDKDelayedPaymentBasepoint* operator &() const { return &self; }
+	const LDKDelayedPaymentBasepoint* operator ->() const { return &self; }
+};
+class DelayedPaymentKey {
+private:
+	LDKDelayedPaymentKey self;
+public:
+	DelayedPaymentKey(const DelayedPaymentKey&) = delete;
+	DelayedPaymentKey(DelayedPaymentKey&& o) : self(o.self) { memset(&o, 0, sizeof(DelayedPaymentKey)); }
+	DelayedPaymentKey(LDKDelayedPaymentKey&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDelayedPaymentKey)); }
+	operator LDKDelayedPaymentKey() && { LDKDelayedPaymentKey res = self; memset(&self, 0, sizeof(LDKDelayedPaymentKey)); return res; }
+	~DelayedPaymentKey() { DelayedPaymentKey_free(self); }
+	DelayedPaymentKey& operator=(DelayedPaymentKey&& o) { DelayedPaymentKey_free(self); self = o.self; memset(&o, 0, sizeof(DelayedPaymentKey)); return *this; }
+	LDKDelayedPaymentKey* operator &() { return &self; }
+	LDKDelayedPaymentKey* operator ->() { return &self; }
+	const LDKDelayedPaymentKey* operator &() const { return &self; }
+	const LDKDelayedPaymentKey* operator ->() const { return &self; }
+};
+class HtlcBasepoint {
+private:
+	LDKHtlcBasepoint self;
+public:
+	HtlcBasepoint(const HtlcBasepoint&) = delete;
+	HtlcBasepoint(HtlcBasepoint&& o) : self(o.self) { memset(&o, 0, sizeof(HtlcBasepoint)); }
+	HtlcBasepoint(LDKHtlcBasepoint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHtlcBasepoint)); }
+	operator LDKHtlcBasepoint() && { LDKHtlcBasepoint res = self; memset(&self, 0, sizeof(LDKHtlcBasepoint)); return res; }
+	~HtlcBasepoint() { HtlcBasepoint_free(self); }
+	HtlcBasepoint& operator=(HtlcBasepoint&& o) { HtlcBasepoint_free(self); self = o.self; memset(&o, 0, sizeof(HtlcBasepoint)); return *this; }
+	LDKHtlcBasepoint* operator &() { return &self; }
+	LDKHtlcBasepoint* operator ->() { return &self; }
+	const LDKHtlcBasepoint* operator &() const { return &self; }
+	const LDKHtlcBasepoint* operator ->() const { return &self; }
+};
+class HtlcKey {
+private:
+	LDKHtlcKey self;
+public:
+	HtlcKey(const HtlcKey&) = delete;
+	HtlcKey(HtlcKey&& o) : self(o.self) { memset(&o, 0, sizeof(HtlcKey)); }
+	HtlcKey(LDKHtlcKey&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHtlcKey)); }
+	operator LDKHtlcKey() && { LDKHtlcKey res = self; memset(&self, 0, sizeof(LDKHtlcKey)); return res; }
+	~HtlcKey() { HtlcKey_free(self); }
+	HtlcKey& operator=(HtlcKey&& o) { HtlcKey_free(self); self = o.self; memset(&o, 0, sizeof(HtlcKey)); return *this; }
+	LDKHtlcKey* operator &() { return &self; }
+	LDKHtlcKey* operator ->() { return &self; }
+	const LDKHtlcKey* operator &() const { return &self; }
+	const LDKHtlcKey* operator ->() const { return &self; }
+};
+class RevocationBasepoint {
+private:
+	LDKRevocationBasepoint self;
+public:
+	RevocationBasepoint(const RevocationBasepoint&) = delete;
+	RevocationBasepoint(RevocationBasepoint&& o) : self(o.self) { memset(&o, 0, sizeof(RevocationBasepoint)); }
+	RevocationBasepoint(LDKRevocationBasepoint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRevocationBasepoint)); }
+	operator LDKRevocationBasepoint() && { LDKRevocationBasepoint res = self; memset(&self, 0, sizeof(LDKRevocationBasepoint)); return res; }
+	~RevocationBasepoint() { RevocationBasepoint_free(self); }
+	RevocationBasepoint& operator=(RevocationBasepoint&& o) { RevocationBasepoint_free(self); self = o.self; memset(&o, 0, sizeof(RevocationBasepoint)); return *this; }
+	LDKRevocationBasepoint* operator &() { return &self; }
+	LDKRevocationBasepoint* operator ->() { return &self; }
+	const LDKRevocationBasepoint* operator &() const { return &self; }
+	const LDKRevocationBasepoint* operator ->() const { return &self; }
+};
+class RevocationKey {
+private:
+	LDKRevocationKey self;
+public:
+	RevocationKey(const RevocationKey&) = delete;
+	RevocationKey(RevocationKey&& o) : self(o.self) { memset(&o, 0, sizeof(RevocationKey)); }
+	RevocationKey(LDKRevocationKey&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRevocationKey)); }
+	operator LDKRevocationKey() && { LDKRevocationKey res = self; memset(&self, 0, sizeof(LDKRevocationKey)); return res; }
+	~RevocationKey() { RevocationKey_free(self); }
+	RevocationKey& operator=(RevocationKey&& o) { RevocationKey_free(self); self = o.self; memset(&o, 0, sizeof(RevocationKey)); return *this; }
+	LDKRevocationKey* operator &() { return &self; }
+	LDKRevocationKey* operator ->() { return &self; }
+	const LDKRevocationKey* operator &() const { return &self; }
+	const LDKRevocationKey* operator ->() const { return &self; }
 };
 class Persist {
 private:
@@ -5947,8 +7372,9 @@ public:
 	 *  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 [`ChannelMonitorUpdateStatus::InProgress`].
+	 *  The [`ChannelMonitor::get_latest_update_id`] uniquely links this call to [`ChainMonitor::channel_monitor_updated`].
+	 *  For [`Persist::persist_new_channel`], it is only necessary to call [`ChainMonitor::channel_monitor_updated`]
+	 *  when you return [`ChannelMonitorUpdateStatus::InProgress`].
 	 * 
 	 *  See [`Writeable::write`] on [`ChannelMonitor`] for writing out a `ChannelMonitor`
 	 *  and [`ChannelMonitorUpdateStatus`] for requirements when returning errors.
@@ -5956,7 +7382,7 @@ public:
 	 *  [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
 	 *  [`Writeable::write`]: crate::util::ser::Writeable::write
 	 */
-	inline LDK::ChannelMonitorUpdateStatus persist_new_channel(struct LDKOutPoint channel_id, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id);
+	inline LDK::ChannelMonitorUpdateStatus persist_new_channel(struct LDKOutPoint channel_funding_outpoint, const struct LDKChannelMonitor *NONNULL_PTR monitor);
 	/**
 	 *  Update one channel's data. The provided [`ChannelMonitor`] has already applied the given
 	 *  update.
@@ -5974,7 +7400,9 @@ public:
 	 *  If an implementer chooses to persist the updates only, they need to make
 	 *  sure that all the updates are applied to the `ChannelMonitors` *before*
 	 *  the set of channel monitors is given to the `ChannelManager`
-	 *  deserialization routine. See [`ChannelMonitor::update_monitor`] for
+	 *  deserialization routine. If there are any gaps in the persisted [`ChannelMonitorUpdate`]s,
+	 *  implementer can safely ignore [`ChannelMonitorUpdate`]s after the gap and load without them.
+	 *  See [`ChannelMonitor::update_monitor`] for
 	 *  applying a monitor update to a monitor. If full `ChannelMonitors` are
 	 *  persisted, then there is no need to persist individual updates.
 	 * 
@@ -5983,8 +7411,10 @@ 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 [`ChannelMonitorUpdateStatus::InProgress`].
+	 *  The [`ChannelMonitorUpdate::update_id`] or [`ChannelMonitor::get_latest_update_id`] uniquely
+	 *  links this call to [`ChainMonitor::channel_monitor_updated`].
+	 *  For [`Persist::update_persisted_channel`], it is only necessary to call [`ChainMonitor::channel_monitor_updated`]
+	 *  when a [`ChannelMonitorUpdate`] is provided and when you return [`ChannelMonitorUpdateStatus::InProgress`].
 	 * 
 	 *  See [`Writeable::write`] on [`ChannelMonitor`] for writing out a `ChannelMonitor`,
 	 *  [`Writeable::write`] on [`ChannelMonitorUpdate`] for writing out an update, and
@@ -5992,9 +7422,16 @@ public:
 	 * 
 	 *  [`Writeable::write`]: crate::util::ser::Writeable::write
 	 * 
-	 *  Note that update (or a relevant inner pointer) may be NULL or all-0s to represent None
+	 *  Note that monitor_update (or a relevant inner pointer) may be NULL or all-0s to represent None
 	 */
-	inline LDK::ChannelMonitorUpdateStatus update_persisted_channel(struct LDKOutPoint channel_id, struct LDKChannelMonitorUpdate update, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id);
+	inline LDK::ChannelMonitorUpdateStatus update_persisted_channel(struct LDKOutPoint channel_funding_outpoint, struct LDKChannelMonitorUpdate monitor_update, const struct LDKChannelMonitor *NONNULL_PTR monitor);
+	/**
+	 *  Prevents the channel monitor from being loaded on startup.
+	 * 
+	 *  Archiving the data in a backup location (rather than deleting it fully) is useful for
+	 *  hedging against data loss in case of unexpected failure.
+	 */
+	inline void archive_persisted_channel(struct LDKOutPoint channel_funding_outpoint);
 };
 class LockedChannelMonitor {
 private:
@@ -6026,20 +7463,95 @@ public:
 	const LDKChainMonitor* operator &() const { return &self; }
 	const LDKChainMonitor* operator ->() const { return &self; }
 };
-class CResult_LockedChannelMonitorNoneZ {
-private:
-	LDKCResult_LockedChannelMonitorNoneZ self;
-public:
-	CResult_LockedChannelMonitorNoneZ(const CResult_LockedChannelMonitorNoneZ&) = delete;
-	CResult_LockedChannelMonitorNoneZ(CResult_LockedChannelMonitorNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_LockedChannelMonitorNoneZ)); }
-	CResult_LockedChannelMonitorNoneZ(LDKCResult_LockedChannelMonitorNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_LockedChannelMonitorNoneZ)); }
-	operator LDKCResult_LockedChannelMonitorNoneZ() && { LDKCResult_LockedChannelMonitorNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_LockedChannelMonitorNoneZ)); return res; }
-	~CResult_LockedChannelMonitorNoneZ() { CResult_LockedChannelMonitorNoneZ_free(self); }
-	CResult_LockedChannelMonitorNoneZ& operator=(CResult_LockedChannelMonitorNoneZ&& o) { CResult_LockedChannelMonitorNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_LockedChannelMonitorNoneZ)); return *this; }
-	LDKCResult_LockedChannelMonitorNoneZ* operator &() { return &self; }
-	LDKCResult_LockedChannelMonitorNoneZ* operator ->() { return &self; }
-	const LDKCResult_LockedChannelMonitorNoneZ* operator &() const { return &self; }
-	const LDKCResult_LockedChannelMonitorNoneZ* operator ->() const { return &self; }
+class BlindedMessagePath {
+private:
+	LDKBlindedMessagePath self;
+public:
+	BlindedMessagePath(const BlindedMessagePath&) = delete;
+	BlindedMessagePath(BlindedMessagePath&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedMessagePath)); }
+	BlindedMessagePath(LDKBlindedMessagePath&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedMessagePath)); }
+	operator LDKBlindedMessagePath() && { LDKBlindedMessagePath res = self; memset(&self, 0, sizeof(LDKBlindedMessagePath)); return res; }
+	~BlindedMessagePath() { BlindedMessagePath_free(self); }
+	BlindedMessagePath& operator=(BlindedMessagePath&& o) { BlindedMessagePath_free(self); self = o.self; memset(&o, 0, sizeof(BlindedMessagePath)); return *this; }
+	LDKBlindedMessagePath* operator &() { return &self; }
+	LDKBlindedMessagePath* operator ->() { return &self; }
+	const LDKBlindedMessagePath* operator &() const { return &self; }
+	const LDKBlindedMessagePath* operator ->() const { return &self; }
+};
+class NextMessageHop {
+private:
+	LDKNextMessageHop self;
+public:
+	NextMessageHop(const NextMessageHop&) = delete;
+	NextMessageHop(NextMessageHop&& o) : self(o.self) { memset(&o, 0, sizeof(NextMessageHop)); }
+	NextMessageHop(LDKNextMessageHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNextMessageHop)); }
+	operator LDKNextMessageHop() && { LDKNextMessageHop res = self; memset(&self, 0, sizeof(LDKNextMessageHop)); return res; }
+	~NextMessageHop() { NextMessageHop_free(self); }
+	NextMessageHop& operator=(NextMessageHop&& o) { NextMessageHop_free(self); self = o.self; memset(&o, 0, sizeof(NextMessageHop)); return *this; }
+	LDKNextMessageHop* operator &() { return &self; }
+	LDKNextMessageHop* operator ->() { return &self; }
+	const LDKNextMessageHop* operator &() const { return &self; }
+	const LDKNextMessageHop* operator ->() const { return &self; }
+};
+class MessageForwardNode {
+private:
+	LDKMessageForwardNode self;
+public:
+	MessageForwardNode(const MessageForwardNode&) = delete;
+	MessageForwardNode(MessageForwardNode&& o) : self(o.self) { memset(&o, 0, sizeof(MessageForwardNode)); }
+	MessageForwardNode(LDKMessageForwardNode&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageForwardNode)); }
+	operator LDKMessageForwardNode() && { LDKMessageForwardNode res = self; memset(&self, 0, sizeof(LDKMessageForwardNode)); return res; }
+	~MessageForwardNode() { MessageForwardNode_free(self); }
+	MessageForwardNode& operator=(MessageForwardNode&& o) { MessageForwardNode_free(self); self = o.self; memset(&o, 0, sizeof(MessageForwardNode)); return *this; }
+	LDKMessageForwardNode* operator &() { return &self; }
+	LDKMessageForwardNode* operator ->() { return &self; }
+	const LDKMessageForwardNode* operator &() const { return &self; }
+	const LDKMessageForwardNode* operator ->() const { return &self; }
+};
+class MessageContext {
+private:
+	LDKMessageContext self;
+public:
+	MessageContext(const MessageContext&) = delete;
+	MessageContext(MessageContext&& o) : self(o.self) { memset(&o, 0, sizeof(MessageContext)); }
+	MessageContext(LDKMessageContext&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageContext)); }
+	operator LDKMessageContext() && { LDKMessageContext res = self; memset(&self, 0, sizeof(LDKMessageContext)); return res; }
+	~MessageContext() { MessageContext_free(self); }
+	MessageContext& operator=(MessageContext&& o) { MessageContext_free(self); self = o.self; memset(&o, 0, sizeof(MessageContext)); return *this; }
+	LDKMessageContext* operator &() { return &self; }
+	LDKMessageContext* operator ->() { return &self; }
+	const LDKMessageContext* operator &() const { return &self; }
+	const LDKMessageContext* operator ->() const { return &self; }
+};
+class OffersContext {
+private:
+	LDKOffersContext self;
+public:
+	OffersContext(const OffersContext&) = delete;
+	OffersContext(OffersContext&& o) : self(o.self) { memset(&o, 0, sizeof(OffersContext)); }
+	OffersContext(LDKOffersContext&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOffersContext)); }
+	operator LDKOffersContext() && { LDKOffersContext res = self; memset(&self, 0, sizeof(LDKOffersContext)); return res; }
+	~OffersContext() { OffersContext_free(self); }
+	OffersContext& operator=(OffersContext&& o) { OffersContext_free(self); self = o.self; memset(&o, 0, sizeof(OffersContext)); return *this; }
+	LDKOffersContext* operator &() { return &self; }
+	LDKOffersContext* operator ->() { return &self; }
+	const LDKOffersContext* operator &() const { return &self; }
+	const LDKOffersContext* operator ->() const { return &self; }
+};
+class CResult_HtlcKeyDecodeErrorZ {
+private:
+	LDKCResult_HtlcKeyDecodeErrorZ self;
+public:
+	CResult_HtlcKeyDecodeErrorZ(const CResult_HtlcKeyDecodeErrorZ&) = delete;
+	CResult_HtlcKeyDecodeErrorZ(CResult_HtlcKeyDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HtlcKeyDecodeErrorZ)); }
+	CResult_HtlcKeyDecodeErrorZ(LDKCResult_HtlcKeyDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HtlcKeyDecodeErrorZ)); }
+	operator LDKCResult_HtlcKeyDecodeErrorZ() && { LDKCResult_HtlcKeyDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HtlcKeyDecodeErrorZ)); return res; }
+	~CResult_HtlcKeyDecodeErrorZ() { CResult_HtlcKeyDecodeErrorZ_free(self); }
+	CResult_HtlcKeyDecodeErrorZ& operator=(CResult_HtlcKeyDecodeErrorZ&& o) { CResult_HtlcKeyDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HtlcKeyDecodeErrorZ)); return *this; }
+	LDKCResult_HtlcKeyDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_HtlcKeyDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_HtlcKeyDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_HtlcKeyDecodeErrorZ* operator ->() const { return &self; }
 };
 class CResult_TransactionU16LenLimitedNoneZ {
 private:
@@ -6056,20 +7568,35 @@ public:
 	const LDKCResult_TransactionU16LenLimitedNoneZ* operator &() const { return &self; }
 	const LDKCResult_TransactionU16LenLimitedNoneZ* operator ->() const { return &self; }
 };
-class CVec_C2Tuple_BlindedPayInfoBlindedPathZZ {
+class CVec_TrackedSpendableOutputZ {
+private:
+	LDKCVec_TrackedSpendableOutputZ self;
+public:
+	CVec_TrackedSpendableOutputZ(const CVec_TrackedSpendableOutputZ&) = delete;
+	CVec_TrackedSpendableOutputZ(CVec_TrackedSpendableOutputZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TrackedSpendableOutputZ)); }
+	CVec_TrackedSpendableOutputZ(LDKCVec_TrackedSpendableOutputZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TrackedSpendableOutputZ)); }
+	operator LDKCVec_TrackedSpendableOutputZ() && { LDKCVec_TrackedSpendableOutputZ res = self; memset(&self, 0, sizeof(LDKCVec_TrackedSpendableOutputZ)); return res; }
+	~CVec_TrackedSpendableOutputZ() { CVec_TrackedSpendableOutputZ_free(self); }
+	CVec_TrackedSpendableOutputZ& operator=(CVec_TrackedSpendableOutputZ&& o) { CVec_TrackedSpendableOutputZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TrackedSpendableOutputZ)); return *this; }
+	LDKCVec_TrackedSpendableOutputZ* operator &() { return &self; }
+	LDKCVec_TrackedSpendableOutputZ* operator ->() { return &self; }
+	const LDKCVec_TrackedSpendableOutputZ* operator &() const { return &self; }
+	const LDKCVec_TrackedSpendableOutputZ* operator ->() const { return &self; }
+};
+class CResult_LockedChannelMonitorNoneZ {
 private:
-	LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ self;
+	LDKCResult_LockedChannelMonitorNoneZ self;
 public:
-	CVec_C2Tuple_BlindedPayInfoBlindedPathZZ(const CVec_C2Tuple_BlindedPayInfoBlindedPathZZ&) = delete;
-	CVec_C2Tuple_BlindedPayInfoBlindedPathZZ(CVec_C2Tuple_BlindedPayInfoBlindedPathZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_BlindedPayInfoBlindedPathZZ)); }
-	CVec_C2Tuple_BlindedPayInfoBlindedPathZZ(LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ)); }
-	operator LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ() && { LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ)); return res; }
-	~CVec_C2Tuple_BlindedPayInfoBlindedPathZZ() { CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_free(self); }
-	CVec_C2Tuple_BlindedPayInfoBlindedPathZZ& operator=(CVec_C2Tuple_BlindedPayInfoBlindedPathZZ&& o) { CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_BlindedPayInfoBlindedPathZZ)); return *this; }
-	LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ* operator &() { return &self; }
-	LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ* operator ->() { return &self; }
-	const LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ* operator &() const { return &self; }
-	const LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ* operator ->() const { return &self; }
+	CResult_LockedChannelMonitorNoneZ(const CResult_LockedChannelMonitorNoneZ&) = delete;
+	CResult_LockedChannelMonitorNoneZ(CResult_LockedChannelMonitorNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_LockedChannelMonitorNoneZ)); }
+	CResult_LockedChannelMonitorNoneZ(LDKCResult_LockedChannelMonitorNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_LockedChannelMonitorNoneZ)); }
+	operator LDKCResult_LockedChannelMonitorNoneZ() && { LDKCResult_LockedChannelMonitorNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_LockedChannelMonitorNoneZ)); return res; }
+	~CResult_LockedChannelMonitorNoneZ() { CResult_LockedChannelMonitorNoneZ_free(self); }
+	CResult_LockedChannelMonitorNoneZ& operator=(CResult_LockedChannelMonitorNoneZ&& o) { CResult_LockedChannelMonitorNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_LockedChannelMonitorNoneZ)); return *this; }
+	LDKCResult_LockedChannelMonitorNoneZ* operator &() { return &self; }
+	LDKCResult_LockedChannelMonitorNoneZ* operator ->() { return &self; }
+	const LDKCResult_LockedChannelMonitorNoneZ* operator &() const { return &self; }
+	const LDKCResult_LockedChannelMonitorNoneZ* operator ->() const { return &self; }
 };
 class CResult_PhantomRouteHintsDecodeErrorZ {
 private:
@@ -6131,20 +7658,20 @@ public:
 	const LDKCResult_RetryDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_RetryDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ {
+class CResult_BlindedForwardDecodeErrorZ {
 private:
-	LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ self;
+	LDKCResult_BlindedForwardDecodeErrorZ self;
 public:
-	CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ(const CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ&) = delete;
-	CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ(CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ)); }
-	CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ(LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ)); }
-	operator LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ() && { LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ)); return res; }
-	~CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ() { CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_free(self); }
-	CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ& operator=(CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ&& o) { CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ)); return *this; }
-	LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ* operator &() { return &self; }
-	LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ* operator ->() { return &self; }
-	const LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ* operator &() const { return &self; }
-	const LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ* operator ->() const { return &self; }
+	CResult_BlindedForwardDecodeErrorZ(const CResult_BlindedForwardDecodeErrorZ&) = delete;
+	CResult_BlindedForwardDecodeErrorZ(CResult_BlindedForwardDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedForwardDecodeErrorZ)); }
+	CResult_BlindedForwardDecodeErrorZ(LDKCResult_BlindedForwardDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedForwardDecodeErrorZ)); }
+	operator LDKCResult_BlindedForwardDecodeErrorZ() && { LDKCResult_BlindedForwardDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedForwardDecodeErrorZ)); return res; }
+	~CResult_BlindedForwardDecodeErrorZ() { CResult_BlindedForwardDecodeErrorZ_free(self); }
+	CResult_BlindedForwardDecodeErrorZ& operator=(CResult_BlindedForwardDecodeErrorZ&& o) { CResult_BlindedForwardDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedForwardDecodeErrorZ)); return *this; }
+	LDKCResult_BlindedForwardDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_BlindedForwardDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_BlindedForwardDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_BlindedForwardDecodeErrorZ* operator ->() const { return &self; }
 };
 class CResult_ChannelInfoDecodeErrorZ {
 private:
@@ -6161,6 +7688,21 @@ public:
 	const LDKCResult_ChannelInfoDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_ChannelInfoDecodeErrorZ* operator ->() const { return &self; }
 };
+class COption_PaymentContextZ {
+private:
+	LDKCOption_PaymentContextZ self;
+public:
+	COption_PaymentContextZ(const COption_PaymentContextZ&) = delete;
+	COption_PaymentContextZ(COption_PaymentContextZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_PaymentContextZ)); }
+	COption_PaymentContextZ(LDKCOption_PaymentContextZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_PaymentContextZ)); }
+	operator LDKCOption_PaymentContextZ() && { LDKCOption_PaymentContextZ res = self; memset(&self, 0, sizeof(LDKCOption_PaymentContextZ)); return res; }
+	~COption_PaymentContextZ() { COption_PaymentContextZ_free(self); }
+	COption_PaymentContextZ& operator=(COption_PaymentContextZ&& o) { COption_PaymentContextZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_PaymentContextZ)); return *this; }
+	LDKCOption_PaymentContextZ* operator &() { return &self; }
+	LDKCOption_PaymentContextZ* operator ->() { return &self; }
+	const LDKCOption_PaymentContextZ* operator &() const { return &self; }
+	const LDKCOption_PaymentContextZ* operator ->() const { return &self; }
+};
 class COption_MaxDustHTLCExposureZ {
 private:
 	LDKCOption_MaxDustHTLCExposureZ self;
@@ -6191,35 +7733,35 @@ public:
 	const LDKCResult_NoneSendErrorZ* operator &() const { return &self; }
 	const LDKCResult_NoneSendErrorZ* operator ->() const { return &self; }
 };
-class C2Tuple_CVec_u8ZusizeZ {
+class CResult_CVec_u8ZPeerHandleErrorZ {
 private:
-	LDKC2Tuple_CVec_u8ZusizeZ self;
+	LDKCResult_CVec_u8ZPeerHandleErrorZ self;
 public:
-	C2Tuple_CVec_u8ZusizeZ(const C2Tuple_CVec_u8ZusizeZ&) = delete;
-	C2Tuple_CVec_u8ZusizeZ(C2Tuple_CVec_u8ZusizeZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_CVec_u8ZusizeZ)); }
-	C2Tuple_CVec_u8ZusizeZ(LDKC2Tuple_CVec_u8ZusizeZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_CVec_u8ZusizeZ)); }
-	operator LDKC2Tuple_CVec_u8ZusizeZ() && { LDKC2Tuple_CVec_u8ZusizeZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_CVec_u8ZusizeZ)); return res; }
-	~C2Tuple_CVec_u8ZusizeZ() { C2Tuple_CVec_u8ZusizeZ_free(self); }
-	C2Tuple_CVec_u8ZusizeZ& operator=(C2Tuple_CVec_u8ZusizeZ&& o) { C2Tuple_CVec_u8ZusizeZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_CVec_u8ZusizeZ)); return *this; }
-	LDKC2Tuple_CVec_u8ZusizeZ* operator &() { return &self; }
-	LDKC2Tuple_CVec_u8ZusizeZ* operator ->() { return &self; }
-	const LDKC2Tuple_CVec_u8ZusizeZ* operator &() const { return &self; }
-	const LDKC2Tuple_CVec_u8ZusizeZ* operator ->() const { return &self; }
+	CResult_CVec_u8ZPeerHandleErrorZ(const CResult_CVec_u8ZPeerHandleErrorZ&) = delete;
+	CResult_CVec_u8ZPeerHandleErrorZ(CResult_CVec_u8ZPeerHandleErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_u8ZPeerHandleErrorZ)); }
+	CResult_CVec_u8ZPeerHandleErrorZ(LDKCResult_CVec_u8ZPeerHandleErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ)); }
+	operator LDKCResult_CVec_u8ZPeerHandleErrorZ() && { LDKCResult_CVec_u8ZPeerHandleErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ)); return res; }
+	~CResult_CVec_u8ZPeerHandleErrorZ() { CResult_CVec_u8ZPeerHandleErrorZ_free(self); }
+	CResult_CVec_u8ZPeerHandleErrorZ& operator=(CResult_CVec_u8ZPeerHandleErrorZ&& o) { CResult_CVec_u8ZPeerHandleErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_u8ZPeerHandleErrorZ)); return *this; }
+	LDKCResult_CVec_u8ZPeerHandleErrorZ* operator &() { return &self; }
+	LDKCResult_CVec_u8ZPeerHandleErrorZ* operator ->() { return &self; }
+	const LDKCResult_CVec_u8ZPeerHandleErrorZ* operator &() const { return &self; }
+	const LDKCResult_CVec_u8ZPeerHandleErrorZ* operator ->() const { return &self; }
 };
-class COption_OffersMessageZ {
+class CResult_OnionPacketDecodeErrorZ {
 private:
-	LDKCOption_OffersMessageZ self;
+	LDKCResult_OnionPacketDecodeErrorZ self;
 public:
-	COption_OffersMessageZ(const COption_OffersMessageZ&) = delete;
-	COption_OffersMessageZ(COption_OffersMessageZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_OffersMessageZ)); }
-	COption_OffersMessageZ(LDKCOption_OffersMessageZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_OffersMessageZ)); }
-	operator LDKCOption_OffersMessageZ() && { LDKCOption_OffersMessageZ res = self; memset(&self, 0, sizeof(LDKCOption_OffersMessageZ)); return res; }
-	~COption_OffersMessageZ() { COption_OffersMessageZ_free(self); }
-	COption_OffersMessageZ& operator=(COption_OffersMessageZ&& o) { COption_OffersMessageZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_OffersMessageZ)); return *this; }
-	LDKCOption_OffersMessageZ* operator &() { return &self; }
-	LDKCOption_OffersMessageZ* operator ->() { return &self; }
-	const LDKCOption_OffersMessageZ* operator &() const { return &self; }
-	const LDKCOption_OffersMessageZ* operator ->() const { return &self; }
+	CResult_OnionPacketDecodeErrorZ(const CResult_OnionPacketDecodeErrorZ&) = delete;
+	CResult_OnionPacketDecodeErrorZ(CResult_OnionPacketDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OnionPacketDecodeErrorZ)); }
+	CResult_OnionPacketDecodeErrorZ(LDKCResult_OnionPacketDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OnionPacketDecodeErrorZ)); }
+	operator LDKCResult_OnionPacketDecodeErrorZ() && { LDKCResult_OnionPacketDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OnionPacketDecodeErrorZ)); return res; }
+	~CResult_OnionPacketDecodeErrorZ() { CResult_OnionPacketDecodeErrorZ_free(self); }
+	CResult_OnionPacketDecodeErrorZ& operator=(CResult_OnionPacketDecodeErrorZ&& o) { CResult_OnionPacketDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OnionPacketDecodeErrorZ)); return *this; }
+	LDKCResult_OnionPacketDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_OnionPacketDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_OnionPacketDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_OnionPacketDecodeErrorZ* operator ->() const { return &self; }
 };
 class COption_NetworkUpdateZ {
 private:
@@ -6251,21 +7793,6 @@ public:
 	const LDKCOption_u64Z* operator &() const { return &self; }
 	const LDKCOption_u64Z* operator ->() const { return &self; }
 };
-class CResult_CVec_u8ZPeerHandleErrorZ {
-private:
-	LDKCResult_CVec_u8ZPeerHandleErrorZ self;
-public:
-	CResult_CVec_u8ZPeerHandleErrorZ(const CResult_CVec_u8ZPeerHandleErrorZ&) = delete;
-	CResult_CVec_u8ZPeerHandleErrorZ(CResult_CVec_u8ZPeerHandleErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_u8ZPeerHandleErrorZ)); }
-	CResult_CVec_u8ZPeerHandleErrorZ(LDKCResult_CVec_u8ZPeerHandleErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ)); }
-	operator LDKCResult_CVec_u8ZPeerHandleErrorZ() && { LDKCResult_CVec_u8ZPeerHandleErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ)); return res; }
-	~CResult_CVec_u8ZPeerHandleErrorZ() { CResult_CVec_u8ZPeerHandleErrorZ_free(self); }
-	CResult_CVec_u8ZPeerHandleErrorZ& operator=(CResult_CVec_u8ZPeerHandleErrorZ&& o) { CResult_CVec_u8ZPeerHandleErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_u8ZPeerHandleErrorZ)); return *this; }
-	LDKCResult_CVec_u8ZPeerHandleErrorZ* operator &() { return &self; }
-	LDKCResult_CVec_u8ZPeerHandleErrorZ* operator ->() { return &self; }
-	const LDKCResult_CVec_u8ZPeerHandleErrorZ* operator &() const { return &self; }
-	const LDKCResult_CVec_u8ZPeerHandleErrorZ* operator ->() const { return &self; }
-};
 class CResult_GossipTimestampFilterDecodeErrorZ {
 private:
 	LDKCResult_GossipTimestampFilterDecodeErrorZ self;
@@ -6281,6 +7808,21 @@ public:
 	const LDKCResult_GossipTimestampFilterDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_GossipTimestampFilterDecodeErrorZ* operator ->() const { return &self; }
 };
+class C2Tuple_OnionMessageContentsResponseInstructionZ {
+private:
+	LDKC2Tuple_OnionMessageContentsResponseInstructionZ self;
+public:
+	C2Tuple_OnionMessageContentsResponseInstructionZ(const C2Tuple_OnionMessageContentsResponseInstructionZ&) = delete;
+	C2Tuple_OnionMessageContentsResponseInstructionZ(C2Tuple_OnionMessageContentsResponseInstructionZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_OnionMessageContentsResponseInstructionZ)); }
+	C2Tuple_OnionMessageContentsResponseInstructionZ(LDKC2Tuple_OnionMessageContentsResponseInstructionZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_OnionMessageContentsResponseInstructionZ)); }
+	operator LDKC2Tuple_OnionMessageContentsResponseInstructionZ() && { LDKC2Tuple_OnionMessageContentsResponseInstructionZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_OnionMessageContentsResponseInstructionZ)); return res; }
+	~C2Tuple_OnionMessageContentsResponseInstructionZ() { C2Tuple_OnionMessageContentsResponseInstructionZ_free(self); }
+	C2Tuple_OnionMessageContentsResponseInstructionZ& operator=(C2Tuple_OnionMessageContentsResponseInstructionZ&& o) { C2Tuple_OnionMessageContentsResponseInstructionZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_OnionMessageContentsResponseInstructionZ)); return *this; }
+	LDKC2Tuple_OnionMessageContentsResponseInstructionZ* operator &() { return &self; }
+	LDKC2Tuple_OnionMessageContentsResponseInstructionZ* operator ->() { return &self; }
+	const LDKC2Tuple_OnionMessageContentsResponseInstructionZ* operator &() const { return &self; }
+	const LDKC2Tuple_OnionMessageContentsResponseInstructionZ* operator ->() const { return &self; }
+};
 class CResult_RouteHintDecodeErrorZ {
 private:
 	LDKCResult_RouteHintDecodeErrorZ self;
@@ -6446,6 +7988,51 @@ public:
 	const LDKC2Tuple__u1632_u1632Z* operator &() const { return &self; }
 	const LDKC2Tuple__u1632_u1632Z* operator ->() const { return &self; }
 };
+class CVec_C2Tuple_OffersMessageMessageSendInstructionsZZ {
+private:
+	LDKCVec_C2Tuple_OffersMessageMessageSendInstructionsZZ self;
+public:
+	CVec_C2Tuple_OffersMessageMessageSendInstructionsZZ(const CVec_C2Tuple_OffersMessageMessageSendInstructionsZZ&) = delete;
+	CVec_C2Tuple_OffersMessageMessageSendInstructionsZZ(CVec_C2Tuple_OffersMessageMessageSendInstructionsZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_OffersMessageMessageSendInstructionsZZ)); }
+	CVec_C2Tuple_OffersMessageMessageSendInstructionsZZ(LDKCVec_C2Tuple_OffersMessageMessageSendInstructionsZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_OffersMessageMessageSendInstructionsZZ)); }
+	operator LDKCVec_C2Tuple_OffersMessageMessageSendInstructionsZZ() && { LDKCVec_C2Tuple_OffersMessageMessageSendInstructionsZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_OffersMessageMessageSendInstructionsZZ)); return res; }
+	~CVec_C2Tuple_OffersMessageMessageSendInstructionsZZ() { CVec_C2Tuple_OffersMessageMessageSendInstructionsZZ_free(self); }
+	CVec_C2Tuple_OffersMessageMessageSendInstructionsZZ& operator=(CVec_C2Tuple_OffersMessageMessageSendInstructionsZZ&& o) { CVec_C2Tuple_OffersMessageMessageSendInstructionsZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_OffersMessageMessageSendInstructionsZZ)); return *this; }
+	LDKCVec_C2Tuple_OffersMessageMessageSendInstructionsZZ* operator &() { return &self; }
+	LDKCVec_C2Tuple_OffersMessageMessageSendInstructionsZZ* operator ->() { return &self; }
+	const LDKCVec_C2Tuple_OffersMessageMessageSendInstructionsZZ* operator &() const { return &self; }
+	const LDKCVec_C2Tuple_OffersMessageMessageSendInstructionsZZ* operator ->() const { return &self; }
+};
+class C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ {
+private:
+	LDKC2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ self;
+public:
+	C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ(const C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ&) = delete;
+	C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ(C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ)); }
+	C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ(LDKC2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ)); }
+	operator LDKC2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ() && { LDKC2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ)); return res; }
+	~C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ() { C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ_free(self); }
+	C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ& operator=(C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ&& o) { C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ)); return *this; }
+	LDKC2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ* operator &() { return &self; }
+	LDKC2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ* operator ->() { return &self; }
+	const LDKC2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ* operator &() const { return &self; }
+	const LDKC2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ* operator ->() const { return &self; }
+};
+class CResult_TransactionNoneZ {
+private:
+	LDKCResult_TransactionNoneZ self;
+public:
+	CResult_TransactionNoneZ(const CResult_TransactionNoneZ&) = delete;
+	CResult_TransactionNoneZ(CResult_TransactionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TransactionNoneZ)); }
+	CResult_TransactionNoneZ(LDKCResult_TransactionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TransactionNoneZ)); }
+	operator LDKCResult_TransactionNoneZ() && { LDKCResult_TransactionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TransactionNoneZ)); return res; }
+	~CResult_TransactionNoneZ() { CResult_TransactionNoneZ_free(self); }
+	CResult_TransactionNoneZ& operator=(CResult_TransactionNoneZ&& o) { CResult_TransactionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TransactionNoneZ)); return *this; }
+	LDKCResult_TransactionNoneZ* operator &() { return &self; }
+	LDKCResult_TransactionNoneZ* operator ->() { return &self; }
+	const LDKCResult_TransactionNoneZ* operator &() const { return &self; }
+	const LDKCResult_TransactionNoneZ* operator ->() const { return &self; }
+};
 class CResult_CVec_StrZIOErrorZ {
 private:
 	LDKCResult_CVec_StrZIOErrorZ self;
@@ -6461,6 +8048,36 @@ public:
 	const LDKCResult_CVec_StrZIOErrorZ* operator &() const { return &self; }
 	const LDKCResult_CVec_StrZIOErrorZ* operator ->() const { return &self; }
 };
+class CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ {
+private:
+	LDKCResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ self;
+public:
+	CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ(const CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ&) = delete;
+	CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ(CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ)); }
+	CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ(LDKCResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ)); }
+	operator LDKCResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ() && { LDKCResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ)); return res; }
+	~CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ() { CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ_free(self); }
+	CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ& operator=(CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ&& o) { CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ)); return *this; }
+	LDKCResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ* operator &() { return &self; }
+	LDKCResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ* operator ->() { return &self; }
+	const LDKCResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ* operator &() const { return &self; }
+	const LDKCResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ* operator ->() const { return &self; }
+};
+class COption_ECDSASignatureZ {
+private:
+	LDKCOption_ECDSASignatureZ self;
+public:
+	COption_ECDSASignatureZ(const COption_ECDSASignatureZ&) = delete;
+	COption_ECDSASignatureZ(COption_ECDSASignatureZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_ECDSASignatureZ)); }
+	COption_ECDSASignatureZ(LDKCOption_ECDSASignatureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_ECDSASignatureZ)); }
+	operator LDKCOption_ECDSASignatureZ() && { LDKCOption_ECDSASignatureZ res = self; memset(&self, 0, sizeof(LDKCOption_ECDSASignatureZ)); return res; }
+	~COption_ECDSASignatureZ() { COption_ECDSASignatureZ_free(self); }
+	COption_ECDSASignatureZ& operator=(COption_ECDSASignatureZ&& o) { COption_ECDSASignatureZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_ECDSASignatureZ)); return *this; }
+	LDKCOption_ECDSASignatureZ* operator &() { return &self; }
+	LDKCOption_ECDSASignatureZ* operator ->() { return &self; }
+	const LDKCOption_ECDSASignatureZ* operator &() const { return &self; }
+	const LDKCOption_ECDSASignatureZ* operator ->() const { return &self; }
+};
 class CResult_ClosingSignedFeeRangeDecodeErrorZ {
 private:
 	LDKCResult_ClosingSignedFeeRangeDecodeErrorZ self;
@@ -6476,21 +8093,6 @@ public:
 	const LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_TransactionNoneZ {
-private:
-	LDKCResult_TransactionNoneZ self;
-public:
-	CResult_TransactionNoneZ(const CResult_TransactionNoneZ&) = delete;
-	CResult_TransactionNoneZ(CResult_TransactionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TransactionNoneZ)); }
-	CResult_TransactionNoneZ(LDKCResult_TransactionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TransactionNoneZ)); }
-	operator LDKCResult_TransactionNoneZ() && { LDKCResult_TransactionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TransactionNoneZ)); return res; }
-	~CResult_TransactionNoneZ() { CResult_TransactionNoneZ_free(self); }
-	CResult_TransactionNoneZ& operator=(CResult_TransactionNoneZ&& o) { CResult_TransactionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TransactionNoneZ)); return *this; }
-	LDKCResult_TransactionNoneZ* operator &() { return &self; }
-	LDKCResult_TransactionNoneZ* operator ->() { return &self; }
-	const LDKCResult_TransactionNoneZ* operator &() const { return &self; }
-	const LDKCResult_TransactionNoneZ* operator ->() const { return &self; }
-};
 class CResult_CommitmentSignedDecodeErrorZ {
 private:
 	LDKCResult_CommitmentSignedDecodeErrorZ self;
@@ -6521,20 +8123,35 @@ public:
 	const LDKCResult_CommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_CommitmentTransactionDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_ErrorMessageDecodeErrorZ {
+class CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ {
 private:
-	LDKCResult_ErrorMessageDecodeErrorZ self;
+	LDKCResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ self;
 public:
-	CResult_ErrorMessageDecodeErrorZ(const CResult_ErrorMessageDecodeErrorZ&) = delete;
-	CResult_ErrorMessageDecodeErrorZ(CResult_ErrorMessageDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ErrorMessageDecodeErrorZ)); }
-	CResult_ErrorMessageDecodeErrorZ(LDKCResult_ErrorMessageDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ErrorMessageDecodeErrorZ)); }
-	operator LDKCResult_ErrorMessageDecodeErrorZ() && { LDKCResult_ErrorMessageDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ErrorMessageDecodeErrorZ)); return res; }
-	~CResult_ErrorMessageDecodeErrorZ() { CResult_ErrorMessageDecodeErrorZ_free(self); }
-	CResult_ErrorMessageDecodeErrorZ& operator=(CResult_ErrorMessageDecodeErrorZ&& o) { CResult_ErrorMessageDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ErrorMessageDecodeErrorZ)); return *this; }
-	LDKCResult_ErrorMessageDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_ErrorMessageDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_ErrorMessageDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_ErrorMessageDecodeErrorZ* operator ->() const { return &self; }
+	CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ(const CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ&) = delete;
+	CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ(CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ)); }
+	CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ(LDKCResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ)); }
+	operator LDKCResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ() && { LDKCResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ)); return res; }
+	~CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ() { CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ_free(self); }
+	CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ& operator=(CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ&& o) { CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ)); return *this; }
+	LDKCResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_StfuDecodeErrorZ {
+private:
+	LDKCResult_StfuDecodeErrorZ self;
+public:
+	CResult_StfuDecodeErrorZ(const CResult_StfuDecodeErrorZ&) = delete;
+	CResult_StfuDecodeErrorZ(CResult_StfuDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_StfuDecodeErrorZ)); }
+	CResult_StfuDecodeErrorZ(LDKCResult_StfuDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_StfuDecodeErrorZ)); }
+	operator LDKCResult_StfuDecodeErrorZ() && { LDKCResult_StfuDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_StfuDecodeErrorZ)); return res; }
+	~CResult_StfuDecodeErrorZ() { CResult_StfuDecodeErrorZ_free(self); }
+	CResult_StfuDecodeErrorZ& operator=(CResult_StfuDecodeErrorZ&& o) { CResult_StfuDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_StfuDecodeErrorZ)); return *this; }
+	LDKCResult_StfuDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_StfuDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_StfuDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_StfuDecodeErrorZ* operator ->() const { return &self; }
 };
 class CResult_OpenChannelDecodeErrorZ {
 private:
@@ -6551,6 +8168,21 @@ public:
 	const LDKCResult_OpenChannelDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_OpenChannelDecodeErrorZ* operator ->() const { return &self; }
 };
+class CResult_ErrorMessageDecodeErrorZ {
+private:
+	LDKCResult_ErrorMessageDecodeErrorZ self;
+public:
+	CResult_ErrorMessageDecodeErrorZ(const CResult_ErrorMessageDecodeErrorZ&) = delete;
+	CResult_ErrorMessageDecodeErrorZ(CResult_ErrorMessageDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ErrorMessageDecodeErrorZ)); }
+	CResult_ErrorMessageDecodeErrorZ(LDKCResult_ErrorMessageDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ErrorMessageDecodeErrorZ)); }
+	operator LDKCResult_ErrorMessageDecodeErrorZ() && { LDKCResult_ErrorMessageDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ErrorMessageDecodeErrorZ)); return res; }
+	~CResult_ErrorMessageDecodeErrorZ() { CResult_ErrorMessageDecodeErrorZ_free(self); }
+	CResult_ErrorMessageDecodeErrorZ& operator=(CResult_ErrorMessageDecodeErrorZ&& o) { CResult_ErrorMessageDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ErrorMessageDecodeErrorZ)); return *this; }
+	LDKCResult_ErrorMessageDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_ErrorMessageDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_ErrorMessageDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_ErrorMessageDecodeErrorZ* operator ->() const { return &self; }
+};
 class COption_APIErrorZ {
 private:
 	LDKCOption_APIErrorZ self;
@@ -6566,6 +8198,36 @@ public:
 	const LDKCOption_APIErrorZ* operator &() const { return &self; }
 	const LDKCOption_APIErrorZ* operator ->() const { return &self; }
 };
+class CVec_PeerDetailsZ {
+private:
+	LDKCVec_PeerDetailsZ self;
+public:
+	CVec_PeerDetailsZ(const CVec_PeerDetailsZ&) = delete;
+	CVec_PeerDetailsZ(CVec_PeerDetailsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PeerDetailsZ)); }
+	CVec_PeerDetailsZ(LDKCVec_PeerDetailsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PeerDetailsZ)); }
+	operator LDKCVec_PeerDetailsZ() && { LDKCVec_PeerDetailsZ res = self; memset(&self, 0, sizeof(LDKCVec_PeerDetailsZ)); return res; }
+	~CVec_PeerDetailsZ() { CVec_PeerDetailsZ_free(self); }
+	CVec_PeerDetailsZ& operator=(CVec_PeerDetailsZ&& o) { CVec_PeerDetailsZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PeerDetailsZ)); return *this; }
+	LDKCVec_PeerDetailsZ* operator &() { return &self; }
+	LDKCVec_PeerDetailsZ* operator ->() { return &self; }
+	const LDKCVec_PeerDetailsZ* operator &() const { return &self; }
+	const LDKCVec_PeerDetailsZ* operator ->() const { return &self; }
+};
+class CResult_u64ShortChannelIdErrorZ {
+private:
+	LDKCResult_u64ShortChannelIdErrorZ self;
+public:
+	CResult_u64ShortChannelIdErrorZ(const CResult_u64ShortChannelIdErrorZ&) = delete;
+	CResult_u64ShortChannelIdErrorZ(CResult_u64ShortChannelIdErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_u64ShortChannelIdErrorZ)); }
+	CResult_u64ShortChannelIdErrorZ(LDKCResult_u64ShortChannelIdErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_u64ShortChannelIdErrorZ)); }
+	operator LDKCResult_u64ShortChannelIdErrorZ() && { LDKCResult_u64ShortChannelIdErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_u64ShortChannelIdErrorZ)); return res; }
+	~CResult_u64ShortChannelIdErrorZ() { CResult_u64ShortChannelIdErrorZ_free(self); }
+	CResult_u64ShortChannelIdErrorZ& operator=(CResult_u64ShortChannelIdErrorZ&& o) { CResult_u64ShortChannelIdErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_u64ShortChannelIdErrorZ)); return *this; }
+	LDKCResult_u64ShortChannelIdErrorZ* operator &() { return &self; }
+	LDKCResult_u64ShortChannelIdErrorZ* operator ->() { return &self; }
+	const LDKCResult_u64ShortChannelIdErrorZ* operator &() const { return &self; }
+	const LDKCResult_u64ShortChannelIdErrorZ* operator ->() const { return &self; }
+};
 class CResult_QueryChannelRangeDecodeErrorZ {
 private:
 	LDKCResult_QueryChannelRangeDecodeErrorZ self;
@@ -6581,21 +8243,6 @@ public:
 	const LDKCResult_QueryChannelRangeDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_QueryChannelRangeDecodeErrorZ* operator ->() const { return &self; }
 };
-class CVec_TransactionZ {
-private:
-	LDKCVec_TransactionZ self;
-public:
-	CVec_TransactionZ(const CVec_TransactionZ&) = delete;
-	CVec_TransactionZ(CVec_TransactionZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TransactionZ)); }
-	CVec_TransactionZ(LDKCVec_TransactionZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TransactionZ)); }
-	operator LDKCVec_TransactionZ() && { LDKCVec_TransactionZ res = self; memset(&self, 0, sizeof(LDKCVec_TransactionZ)); return res; }
-	~CVec_TransactionZ() { CVec_TransactionZ_free(self); }
-	CVec_TransactionZ& operator=(CVec_TransactionZ&& o) { CVec_TransactionZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TransactionZ)); return *this; }
-	LDKCVec_TransactionZ* operator &() { return &self; }
-	LDKCVec_TransactionZ* operator ->() { return &self; }
-	const LDKCVec_TransactionZ* operator &() const { return &self; }
-	const LDKCVec_TransactionZ* operator ->() const { return &self; }
-};
 class CVec_InputZ {
 private:
 	LDKCVec_InputZ self;
@@ -6641,6 +8288,21 @@ public:
 	const LDKCResult_ChannelReadyDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_ChannelReadyDecodeErrorZ* operator ->() const { return &self; }
 };
+class CVec_TransactionZ {
+private:
+	LDKCVec_TransactionZ self;
+public:
+	CVec_TransactionZ(const CVec_TransactionZ&) = delete;
+	CVec_TransactionZ(CVec_TransactionZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TransactionZ)); }
+	CVec_TransactionZ(LDKCVec_TransactionZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TransactionZ)); }
+	operator LDKCVec_TransactionZ() && { LDKCVec_TransactionZ res = self; memset(&self, 0, sizeof(LDKCVec_TransactionZ)); return res; }
+	~CVec_TransactionZ() { CVec_TransactionZ_free(self); }
+	CVec_TransactionZ& operator=(CVec_TransactionZ&& o) { CVec_TransactionZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TransactionZ)); return *this; }
+	LDKCVec_TransactionZ* operator &() { return &self; }
+	LDKCVec_TransactionZ* operator ->() { return &self; }
+	const LDKCVec_TransactionZ* operator &() const { return &self; }
+	const LDKCVec_TransactionZ* operator ->() const { return &self; }
+};
 class CResult_UpdateFeeDecodeErrorZ {
 private:
 	LDKCResult_UpdateFeeDecodeErrorZ self;
@@ -6671,6 +8333,21 @@ public:
 	const LDKCResult_NoneBolt11SemanticErrorZ* operator &() const { return &self; }
 	const LDKCResult_NoneBolt11SemanticErrorZ* operator ->() const { return &self; }
 };
+class CResult_RevocationBasepointDecodeErrorZ {
+private:
+	LDKCResult_RevocationBasepointDecodeErrorZ self;
+public:
+	CResult_RevocationBasepointDecodeErrorZ(const CResult_RevocationBasepointDecodeErrorZ&) = delete;
+	CResult_RevocationBasepointDecodeErrorZ(CResult_RevocationBasepointDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RevocationBasepointDecodeErrorZ)); }
+	CResult_RevocationBasepointDecodeErrorZ(LDKCResult_RevocationBasepointDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RevocationBasepointDecodeErrorZ)); }
+	operator LDKCResult_RevocationBasepointDecodeErrorZ() && { LDKCResult_RevocationBasepointDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RevocationBasepointDecodeErrorZ)); return res; }
+	~CResult_RevocationBasepointDecodeErrorZ() { CResult_RevocationBasepointDecodeErrorZ_free(self); }
+	CResult_RevocationBasepointDecodeErrorZ& operator=(CResult_RevocationBasepointDecodeErrorZ&& o) { CResult_RevocationBasepointDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RevocationBasepointDecodeErrorZ)); return *this; }
+	LDKCResult_RevocationBasepointDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_RevocationBasepointDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_RevocationBasepointDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_RevocationBasepointDecodeErrorZ* operator ->() const { return &self; }
+};
 class COption_OnionMessageContentsZ {
 private:
 	LDKCOption_OnionMessageContentsZ self;
@@ -6701,20 +8378,20 @@ public:
 	const LDKCResult_NoneRetryableSendFailureZ* operator &() const { return &self; }
 	const LDKCResult_NoneRetryableSendFailureZ* operator ->() const { return &self; }
 };
-class CResult_boolLightningErrorZ {
+class CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ {
 private:
-	LDKCResult_boolLightningErrorZ self;
+	LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ self;
 public:
-	CResult_boolLightningErrorZ(const CResult_boolLightningErrorZ&) = delete;
-	CResult_boolLightningErrorZ(CResult_boolLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_boolLightningErrorZ)); }
-	CResult_boolLightningErrorZ(LDKCResult_boolLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_boolLightningErrorZ)); }
-	operator LDKCResult_boolLightningErrorZ() && { LDKCResult_boolLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_boolLightningErrorZ)); return res; }
-	~CResult_boolLightningErrorZ() { CResult_boolLightningErrorZ_free(self); }
-	CResult_boolLightningErrorZ& operator=(CResult_boolLightningErrorZ&& o) { CResult_boolLightningErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_boolLightningErrorZ)); return *this; }
-	LDKCResult_boolLightningErrorZ* operator &() { return &self; }
-	LDKCResult_boolLightningErrorZ* operator ->() { return &self; }
-	const LDKCResult_boolLightningErrorZ* operator &() const { return &self; }
-	const LDKCResult_boolLightningErrorZ* operator ->() const { return &self; }
+	CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ(const CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ&) = delete;
+	CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ(CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ)); }
+	CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ(LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ)); }
+	operator LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ() && { LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ)); return res; }
+	~CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ() { CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ_free(self); }
+	CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ& operator=(CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ&& o) { CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ)); return *this; }
+	LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ* operator &() { return &self; }
+	LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ* operator ->() { return &self; }
+	const LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ* operator &() const { return &self; }
+	const LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ* operator ->() const { return &self; }
 };
 class CResult_NodeIdDecodeErrorZ {
 private:
@@ -6731,6 +8408,21 @@ public:
 	const LDKCResult_NodeIdDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_NodeIdDecodeErrorZ* operator ->() const { return &self; }
 };
+class CResult_boolLightningErrorZ {
+private:
+	LDKCResult_boolLightningErrorZ self;
+public:
+	CResult_boolLightningErrorZ(const CResult_boolLightningErrorZ&) = delete;
+	CResult_boolLightningErrorZ(CResult_boolLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_boolLightningErrorZ)); }
+	CResult_boolLightningErrorZ(LDKCResult_boolLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_boolLightningErrorZ)); }
+	operator LDKCResult_boolLightningErrorZ() && { LDKCResult_boolLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_boolLightningErrorZ)); return res; }
+	~CResult_boolLightningErrorZ() { CResult_boolLightningErrorZ_free(self); }
+	CResult_boolLightningErrorZ& operator=(CResult_boolLightningErrorZ&& o) { CResult_boolLightningErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_boolLightningErrorZ)); return *this; }
+	LDKCResult_boolLightningErrorZ* operator &() { return &self; }
+	LDKCResult_boolLightningErrorZ* operator ->() { return &self; }
+	const LDKCResult_boolLightningErrorZ* operator &() const { return &self; }
+	const LDKCResult_boolLightningErrorZ* operator ->() const { return &self; }
+};
 class CResult_ChannelShutdownStateDecodeErrorZ {
 private:
 	LDKCResult_ChannelShutdownStateDecodeErrorZ self;
@@ -6746,21 +8438,6 @@ public:
 	const LDKCResult_ChannelShutdownStateDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_ChannelShutdownStateDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_HTLCOutputInCommitmentDecodeErrorZ {
-private:
-	LDKCResult_HTLCOutputInCommitmentDecodeErrorZ self;
-public:
-	CResult_HTLCOutputInCommitmentDecodeErrorZ(const CResult_HTLCOutputInCommitmentDecodeErrorZ&) = delete;
-	CResult_HTLCOutputInCommitmentDecodeErrorZ(CResult_HTLCOutputInCommitmentDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HTLCOutputInCommitmentDecodeErrorZ)); }
-	CResult_HTLCOutputInCommitmentDecodeErrorZ(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ)); }
-	operator LDKCResult_HTLCOutputInCommitmentDecodeErrorZ() && { LDKCResult_HTLCOutputInCommitmentDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ)); return res; }
-	~CResult_HTLCOutputInCommitmentDecodeErrorZ() { CResult_HTLCOutputInCommitmentDecodeErrorZ_free(self); }
-	CResult_HTLCOutputInCommitmentDecodeErrorZ& operator=(CResult_HTLCOutputInCommitmentDecodeErrorZ&& o) { CResult_HTLCOutputInCommitmentDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HTLCOutputInCommitmentDecodeErrorZ)); return *this; }
-	LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator ->() const { return &self; }
-};
 class CResult_NodeAnnouncementInfoDecodeErrorZ {
 private:
 	LDKCResult_NodeAnnouncementInfoDecodeErrorZ self;
@@ -6776,20 +8453,20 @@ public:
 	const LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_ShutdownScriptInvalidShutdownScriptZ {
+class CResult_InvoiceRequestBolt12SemanticErrorZ {
 private:
-	LDKCResult_ShutdownScriptInvalidShutdownScriptZ self;
+	LDKCResult_InvoiceRequestBolt12SemanticErrorZ self;
 public:
-	CResult_ShutdownScriptInvalidShutdownScriptZ(const CResult_ShutdownScriptInvalidShutdownScriptZ&) = delete;
-	CResult_ShutdownScriptInvalidShutdownScriptZ(CResult_ShutdownScriptInvalidShutdownScriptZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ShutdownScriptInvalidShutdownScriptZ)); }
-	CResult_ShutdownScriptInvalidShutdownScriptZ(LDKCResult_ShutdownScriptInvalidShutdownScriptZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ)); }
-	operator LDKCResult_ShutdownScriptInvalidShutdownScriptZ() && { LDKCResult_ShutdownScriptInvalidShutdownScriptZ res = self; memset(&self, 0, sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ)); return res; }
-	~CResult_ShutdownScriptInvalidShutdownScriptZ() { CResult_ShutdownScriptInvalidShutdownScriptZ_free(self); }
-	CResult_ShutdownScriptInvalidShutdownScriptZ& operator=(CResult_ShutdownScriptInvalidShutdownScriptZ&& o) { CResult_ShutdownScriptInvalidShutdownScriptZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ShutdownScriptInvalidShutdownScriptZ)); return *this; }
-	LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator &() { return &self; }
-	LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator ->() { return &self; }
-	const LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator &() const { return &self; }
-	const LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator ->() const { return &self; }
+	CResult_InvoiceRequestBolt12SemanticErrorZ(const CResult_InvoiceRequestBolt12SemanticErrorZ&) = delete;
+	CResult_InvoiceRequestBolt12SemanticErrorZ(CResult_InvoiceRequestBolt12SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceRequestBolt12SemanticErrorZ)); }
+	CResult_InvoiceRequestBolt12SemanticErrorZ(LDKCResult_InvoiceRequestBolt12SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceRequestBolt12SemanticErrorZ)); }
+	operator LDKCResult_InvoiceRequestBolt12SemanticErrorZ() && { LDKCResult_InvoiceRequestBolt12SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceRequestBolt12SemanticErrorZ)); return res; }
+	~CResult_InvoiceRequestBolt12SemanticErrorZ() { CResult_InvoiceRequestBolt12SemanticErrorZ_free(self); }
+	CResult_InvoiceRequestBolt12SemanticErrorZ& operator=(CResult_InvoiceRequestBolt12SemanticErrorZ&& o) { CResult_InvoiceRequestBolt12SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceRequestBolt12SemanticErrorZ)); return *this; }
+	LDKCResult_InvoiceRequestBolt12SemanticErrorZ* operator &() { return &self; }
+	LDKCResult_InvoiceRequestBolt12SemanticErrorZ* operator ->() { return &self; }
+	const LDKCResult_InvoiceRequestBolt12SemanticErrorZ* operator &() const { return &self; }
+	const LDKCResult_InvoiceRequestBolt12SemanticErrorZ* operator ->() const { return &self; }
 };
 class CResult_COption_NetworkUpdateZDecodeErrorZ {
 private:
@@ -6836,35 +8513,80 @@ public:
 	const LDKCResult_ShutdownScriptNoneZ* operator &() const { return &self; }
 	const LDKCResult_ShutdownScriptNoneZ* operator ->() const { return &self; }
 };
-class COption_HTLCDestinationZ {
-private:
-	LDKCOption_HTLCDestinationZ self;
-public:
-	COption_HTLCDestinationZ(const COption_HTLCDestinationZ&) = delete;
-	COption_HTLCDestinationZ(COption_HTLCDestinationZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_HTLCDestinationZ)); }
-	COption_HTLCDestinationZ(LDKCOption_HTLCDestinationZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_HTLCDestinationZ)); }
-	operator LDKCOption_HTLCDestinationZ() && { LDKCOption_HTLCDestinationZ res = self; memset(&self, 0, sizeof(LDKCOption_HTLCDestinationZ)); return res; }
-	~COption_HTLCDestinationZ() { COption_HTLCDestinationZ_free(self); }
-	COption_HTLCDestinationZ& operator=(COption_HTLCDestinationZ&& o) { COption_HTLCDestinationZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_HTLCDestinationZ)); return *this; }
-	LDKCOption_HTLCDestinationZ* operator &() { return &self; }
-	LDKCOption_HTLCDestinationZ* operator ->() { return &self; }
-	const LDKCOption_HTLCDestinationZ* operator &() const { return &self; }
-	const LDKCOption_HTLCDestinationZ* operator ->() const { return &self; }
+class CResult_PendingHTLCInfoInboundHTLCErrZ {
+private:
+	LDKCResult_PendingHTLCInfoInboundHTLCErrZ self;
+public:
+	CResult_PendingHTLCInfoInboundHTLCErrZ(const CResult_PendingHTLCInfoInboundHTLCErrZ&) = delete;
+	CResult_PendingHTLCInfoInboundHTLCErrZ(CResult_PendingHTLCInfoInboundHTLCErrZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PendingHTLCInfoInboundHTLCErrZ)); }
+	CResult_PendingHTLCInfoInboundHTLCErrZ(LDKCResult_PendingHTLCInfoInboundHTLCErrZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PendingHTLCInfoInboundHTLCErrZ)); }
+	operator LDKCResult_PendingHTLCInfoInboundHTLCErrZ() && { LDKCResult_PendingHTLCInfoInboundHTLCErrZ res = self; memset(&self, 0, sizeof(LDKCResult_PendingHTLCInfoInboundHTLCErrZ)); return res; }
+	~CResult_PendingHTLCInfoInboundHTLCErrZ() { CResult_PendingHTLCInfoInboundHTLCErrZ_free(self); }
+	CResult_PendingHTLCInfoInboundHTLCErrZ& operator=(CResult_PendingHTLCInfoInboundHTLCErrZ&& o) { CResult_PendingHTLCInfoInboundHTLCErrZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PendingHTLCInfoInboundHTLCErrZ)); return *this; }
+	LDKCResult_PendingHTLCInfoInboundHTLCErrZ* operator &() { return &self; }
+	LDKCResult_PendingHTLCInfoInboundHTLCErrZ* operator ->() { return &self; }
+	const LDKCResult_PendingHTLCInfoInboundHTLCErrZ* operator &() const { return &self; }
+	const LDKCResult_PendingHTLCInfoInboundHTLCErrZ* operator ->() const { return &self; }
+};
+class CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ {
+private:
+	LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ self;
+public:
+	CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ(const CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ&) = delete;
+	CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ(CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ)); }
+	CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ(LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ)); }
+	operator LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ() && { LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ)); return res; }
+	~CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ() { CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_free(self); }
+	CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ& operator=(CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ&& o) { CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ)); return *this; }
+	LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ* operator &() { return &self; }
+	LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ* operator ->() { return &self; }
+	const LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ* operator &() const { return &self; }
+	const LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ* operator ->() const { return &self; }
+};
+class CResult_PendingHTLCInfoDecodeErrorZ {
+private:
+	LDKCResult_PendingHTLCInfoDecodeErrorZ self;
+public:
+	CResult_PendingHTLCInfoDecodeErrorZ(const CResult_PendingHTLCInfoDecodeErrorZ&) = delete;
+	CResult_PendingHTLCInfoDecodeErrorZ(CResult_PendingHTLCInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PendingHTLCInfoDecodeErrorZ)); }
+	CResult_PendingHTLCInfoDecodeErrorZ(LDKCResult_PendingHTLCInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PendingHTLCInfoDecodeErrorZ)); }
+	operator LDKCResult_PendingHTLCInfoDecodeErrorZ() && { LDKCResult_PendingHTLCInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PendingHTLCInfoDecodeErrorZ)); return res; }
+	~CResult_PendingHTLCInfoDecodeErrorZ() { CResult_PendingHTLCInfoDecodeErrorZ_free(self); }
+	CResult_PendingHTLCInfoDecodeErrorZ& operator=(CResult_PendingHTLCInfoDecodeErrorZ&& o) { CResult_PendingHTLCInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PendingHTLCInfoDecodeErrorZ)); return *this; }
+	LDKCResult_PendingHTLCInfoDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_PendingHTLCInfoDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_PendingHTLCInfoDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_PendingHTLCInfoDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_SpliceInitDecodeErrorZ {
+private:
+	LDKCResult_SpliceInitDecodeErrorZ self;
+public:
+	CResult_SpliceInitDecodeErrorZ(const CResult_SpliceInitDecodeErrorZ&) = delete;
+	CResult_SpliceInitDecodeErrorZ(CResult_SpliceInitDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SpliceInitDecodeErrorZ)); }
+	CResult_SpliceInitDecodeErrorZ(LDKCResult_SpliceInitDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SpliceInitDecodeErrorZ)); }
+	operator LDKCResult_SpliceInitDecodeErrorZ() && { LDKCResult_SpliceInitDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SpliceInitDecodeErrorZ)); return res; }
+	~CResult_SpliceInitDecodeErrorZ() { CResult_SpliceInitDecodeErrorZ_free(self); }
+	CResult_SpliceInitDecodeErrorZ& operator=(CResult_SpliceInitDecodeErrorZ&& o) { CResult_SpliceInitDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SpliceInitDecodeErrorZ)); return *this; }
+	LDKCResult_SpliceInitDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_SpliceInitDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_SpliceInitDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_SpliceInitDecodeErrorZ* operator ->() const { return &self; }
 };
-class CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ {
+class CResult_HTLCOutputInCommitmentDecodeErrorZ {
 private:
-	LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ self;
+	LDKCResult_HTLCOutputInCommitmentDecodeErrorZ self;
 public:
-	CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ(const CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ&) = delete;
-	CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ(CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ)); }
-	CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ(LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ)); }
-	operator LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ() && { LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ)); return res; }
-	~CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ() { CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(self); }
-	CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ& operator=(CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ&& o) { CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ)); return *this; }
-	LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ* operator &() { return &self; }
-	LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ* operator ->() { return &self; }
-	const LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ* operator &() const { return &self; }
-	const LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ* operator ->() const { return &self; }
+	CResult_HTLCOutputInCommitmentDecodeErrorZ(const CResult_HTLCOutputInCommitmentDecodeErrorZ&) = delete;
+	CResult_HTLCOutputInCommitmentDecodeErrorZ(CResult_HTLCOutputInCommitmentDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HTLCOutputInCommitmentDecodeErrorZ)); }
+	CResult_HTLCOutputInCommitmentDecodeErrorZ(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ)); }
+	operator LDKCResult_HTLCOutputInCommitmentDecodeErrorZ() && { LDKCResult_HTLCOutputInCommitmentDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ)); return res; }
+	~CResult_HTLCOutputInCommitmentDecodeErrorZ() { CResult_HTLCOutputInCommitmentDecodeErrorZ_free(self); }
+	CResult_HTLCOutputInCommitmentDecodeErrorZ& operator=(CResult_HTLCOutputInCommitmentDecodeErrorZ&& o) { CResult_HTLCOutputInCommitmentDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HTLCOutputInCommitmentDecodeErrorZ)); return *this; }
+	LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator ->() const { return &self; }
 };
 class CVec_RouteHopZ {
 private:
@@ -6881,20 +8603,20 @@ public:
 	const LDKCVec_RouteHopZ* operator &() const { return &self; }
 	const LDKCVec_RouteHopZ* operator ->() const { return &self; }
 };
-class CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ {
+class CResult_ShutdownScriptInvalidShutdownScriptZ {
 private:
-	LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ self;
+	LDKCResult_ShutdownScriptInvalidShutdownScriptZ self;
 public:
-	CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ(const CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ&) = delete;
-	CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ(CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ)); }
-	CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ(LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ)); }
-	operator LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ() && { LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ)); return res; }
-	~CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ() { CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ_free(self); }
-	CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ& operator=(CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ&& o) { CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ)); return *this; }
-	LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ* operator &() { return &self; }
-	LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ* operator ->() { return &self; }
-	const LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ* operator &() const { return &self; }
-	const LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ* operator ->() const { return &self; }
+	CResult_ShutdownScriptInvalidShutdownScriptZ(const CResult_ShutdownScriptInvalidShutdownScriptZ&) = delete;
+	CResult_ShutdownScriptInvalidShutdownScriptZ(CResult_ShutdownScriptInvalidShutdownScriptZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ShutdownScriptInvalidShutdownScriptZ)); }
+	CResult_ShutdownScriptInvalidShutdownScriptZ(LDKCResult_ShutdownScriptInvalidShutdownScriptZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ)); }
+	operator LDKCResult_ShutdownScriptInvalidShutdownScriptZ() && { LDKCResult_ShutdownScriptInvalidShutdownScriptZ res = self; memset(&self, 0, sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ)); return res; }
+	~CResult_ShutdownScriptInvalidShutdownScriptZ() { CResult_ShutdownScriptInvalidShutdownScriptZ_free(self); }
+	CResult_ShutdownScriptInvalidShutdownScriptZ& operator=(CResult_ShutdownScriptInvalidShutdownScriptZ&& o) { CResult_ShutdownScriptInvalidShutdownScriptZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ShutdownScriptInvalidShutdownScriptZ)); return *this; }
+	LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator &() { return &self; }
+	LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator ->() { return &self; }
+	const LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator &() const { return &self; }
+	const LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator ->() const { return &self; }
 };
 class CResult_CVec_UtxoZNoneZ {
 private:
@@ -6926,20 +8648,35 @@ public:
 	const LDKCResult_CVec_u8ZIOErrorZ* operator &() const { return &self; }
 	const LDKCResult_CVec_u8ZIOErrorZ* operator ->() const { return &self; }
 };
-class C3Tuple_OffersMessageDestinationBlindedPathZ {
+class COption_HTLCDestinationZ {
+private:
+	LDKCOption_HTLCDestinationZ self;
+public:
+	COption_HTLCDestinationZ(const COption_HTLCDestinationZ&) = delete;
+	COption_HTLCDestinationZ(COption_HTLCDestinationZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_HTLCDestinationZ)); }
+	COption_HTLCDestinationZ(LDKCOption_HTLCDestinationZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_HTLCDestinationZ)); }
+	operator LDKCOption_HTLCDestinationZ() && { LDKCOption_HTLCDestinationZ res = self; memset(&self, 0, sizeof(LDKCOption_HTLCDestinationZ)); return res; }
+	~COption_HTLCDestinationZ() { COption_HTLCDestinationZ_free(self); }
+	COption_HTLCDestinationZ& operator=(COption_HTLCDestinationZ&& o) { COption_HTLCDestinationZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_HTLCDestinationZ)); return *this; }
+	LDKCOption_HTLCDestinationZ* operator &() { return &self; }
+	LDKCOption_HTLCDestinationZ* operator ->() { return &self; }
+	const LDKCOption_HTLCDestinationZ* operator &() const { return &self; }
+	const LDKCOption_HTLCDestinationZ* operator ->() const { return &self; }
+};
+class CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ {
 private:
-	LDKC3Tuple_OffersMessageDestinationBlindedPathZ self;
+	LDKCResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ self;
 public:
-	C3Tuple_OffersMessageDestinationBlindedPathZ(const C3Tuple_OffersMessageDestinationBlindedPathZ&) = delete;
-	C3Tuple_OffersMessageDestinationBlindedPathZ(C3Tuple_OffersMessageDestinationBlindedPathZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_OffersMessageDestinationBlindedPathZ)); }
-	C3Tuple_OffersMessageDestinationBlindedPathZ(LDKC3Tuple_OffersMessageDestinationBlindedPathZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_OffersMessageDestinationBlindedPathZ)); }
-	operator LDKC3Tuple_OffersMessageDestinationBlindedPathZ() && { LDKC3Tuple_OffersMessageDestinationBlindedPathZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_OffersMessageDestinationBlindedPathZ)); return res; }
-	~C3Tuple_OffersMessageDestinationBlindedPathZ() { C3Tuple_OffersMessageDestinationBlindedPathZ_free(self); }
-	C3Tuple_OffersMessageDestinationBlindedPathZ& operator=(C3Tuple_OffersMessageDestinationBlindedPathZ&& o) { C3Tuple_OffersMessageDestinationBlindedPathZ_free(self); self = o.self; memset(&o, 0, sizeof(C3Tuple_OffersMessageDestinationBlindedPathZ)); return *this; }
-	LDKC3Tuple_OffersMessageDestinationBlindedPathZ* operator &() { return &self; }
-	LDKC3Tuple_OffersMessageDestinationBlindedPathZ* operator ->() { return &self; }
-	const LDKC3Tuple_OffersMessageDestinationBlindedPathZ* operator &() const { return &self; }
-	const LDKC3Tuple_OffersMessageDestinationBlindedPathZ* operator ->() const { return &self; }
+	CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ(const CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ&) = delete;
+	CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ(CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ)); }
+	CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ(LDKCResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ)); }
+	operator LDKCResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ() && { LDKCResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ)); return res; }
+	~CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ() { CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ_free(self); }
+	CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ& operator=(CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ&& o) { CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ)); return *this; }
+	LDKCResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ* operator &() { return &self; }
+	LDKCResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ* operator ->() { return &self; }
+	const LDKCResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ* operator &() const { return &self; }
+	const LDKCResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ* operator ->() const { return &self; }
 };
 class CVec_ThirtyTwoBytesZ {
 private:
@@ -6986,21 +8723,6 @@ public:
 	const LDKCResult_ClosingSignedDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_ClosingSignedDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_NonePaymentErrorZ {
-private:
-	LDKCResult_NonePaymentErrorZ self;
-public:
-	CResult_NonePaymentErrorZ(const CResult_NonePaymentErrorZ&) = delete;
-	CResult_NonePaymentErrorZ(CResult_NonePaymentErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NonePaymentErrorZ)); }
-	CResult_NonePaymentErrorZ(LDKCResult_NonePaymentErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NonePaymentErrorZ)); }
-	operator LDKCResult_NonePaymentErrorZ() && { LDKCResult_NonePaymentErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NonePaymentErrorZ)); return res; }
-	~CResult_NonePaymentErrorZ() { CResult_NonePaymentErrorZ_free(self); }
-	CResult_NonePaymentErrorZ& operator=(CResult_NonePaymentErrorZ&& o) { CResult_NonePaymentErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NonePaymentErrorZ)); return *this; }
-	LDKCResult_NonePaymentErrorZ* operator &() { return &self; }
-	LDKCResult_NonePaymentErrorZ* operator ->() { return &self; }
-	const LDKCResult_NonePaymentErrorZ* operator &() const { return &self; }
-	const LDKCResult_NonePaymentErrorZ* operator ->() const { return &self; }
-};
 class CVec_CResult_NoneAPIErrorZZ {
 private:
 	LDKCVec_CResult_NoneAPIErrorZZ self;
@@ -7031,6 +8753,21 @@ public:
 	const LDKCResult_SchnorrSignatureNoneZ* operator &() const { return &self; }
 	const LDKCResult_SchnorrSignatureNoneZ* operator ->() const { return &self; }
 };
+class C2Tuple_ReleaseHeldHtlcResponseInstructionZ {
+private:
+	LDKC2Tuple_ReleaseHeldHtlcResponseInstructionZ self;
+public:
+	C2Tuple_ReleaseHeldHtlcResponseInstructionZ(const C2Tuple_ReleaseHeldHtlcResponseInstructionZ&) = delete;
+	C2Tuple_ReleaseHeldHtlcResponseInstructionZ(C2Tuple_ReleaseHeldHtlcResponseInstructionZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ReleaseHeldHtlcResponseInstructionZ)); }
+	C2Tuple_ReleaseHeldHtlcResponseInstructionZ(LDKC2Tuple_ReleaseHeldHtlcResponseInstructionZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ReleaseHeldHtlcResponseInstructionZ)); }
+	operator LDKC2Tuple_ReleaseHeldHtlcResponseInstructionZ() && { LDKC2Tuple_ReleaseHeldHtlcResponseInstructionZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ReleaseHeldHtlcResponseInstructionZ)); return res; }
+	~C2Tuple_ReleaseHeldHtlcResponseInstructionZ() { C2Tuple_ReleaseHeldHtlcResponseInstructionZ_free(self); }
+	C2Tuple_ReleaseHeldHtlcResponseInstructionZ& operator=(C2Tuple_ReleaseHeldHtlcResponseInstructionZ&& o) { C2Tuple_ReleaseHeldHtlcResponseInstructionZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_ReleaseHeldHtlcResponseInstructionZ)); return *this; }
+	LDKC2Tuple_ReleaseHeldHtlcResponseInstructionZ* operator &() { return &self; }
+	LDKC2Tuple_ReleaseHeldHtlcResponseInstructionZ* operator ->() { return &self; }
+	const LDKC2Tuple_ReleaseHeldHtlcResponseInstructionZ* operator &() const { return &self; }
+	const LDKC2Tuple_ReleaseHeldHtlcResponseInstructionZ* operator ->() const { return &self; }
+};
 class CResult_CounterpartyCommitmentSecretsDecodeErrorZ {
 private:
 	LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ self;
@@ -7046,21 +8783,6 @@ public:
 	const LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_ReceiveTlvsDecodeErrorZ {
-private:
-	LDKCResult_ReceiveTlvsDecodeErrorZ self;
-public:
-	CResult_ReceiveTlvsDecodeErrorZ(const CResult_ReceiveTlvsDecodeErrorZ&) = delete;
-	CResult_ReceiveTlvsDecodeErrorZ(CResult_ReceiveTlvsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ReceiveTlvsDecodeErrorZ)); }
-	CResult_ReceiveTlvsDecodeErrorZ(LDKCResult_ReceiveTlvsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ReceiveTlvsDecodeErrorZ)); }
-	operator LDKCResult_ReceiveTlvsDecodeErrorZ() && { LDKCResult_ReceiveTlvsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ReceiveTlvsDecodeErrorZ)); return res; }
-	~CResult_ReceiveTlvsDecodeErrorZ() { CResult_ReceiveTlvsDecodeErrorZ_free(self); }
-	CResult_ReceiveTlvsDecodeErrorZ& operator=(CResult_ReceiveTlvsDecodeErrorZ&& o) { CResult_ReceiveTlvsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ReceiveTlvsDecodeErrorZ)); return *this; }
-	LDKCResult_ReceiveTlvsDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_ReceiveTlvsDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_ReceiveTlvsDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_ReceiveTlvsDecodeErrorZ* operator ->() const { return &self; }
-};
 class CResult_HTLCDescriptorDecodeErrorZ {
 private:
 	LDKCResult_HTLCDescriptorDecodeErrorZ self;
@@ -7106,21 +8828,6 @@ public:
 	const LDKCVec_RouteHintHopZ* operator &() const { return &self; }
 	const LDKCVec_RouteHintHopZ* operator ->() const { return &self; }
 };
-class CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ {
-private:
-	LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ self;
-public:
-	CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ(const CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ&) = delete;
-	CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ(CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ)); }
-	CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ(LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ)); }
-	operator LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ() && { LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ res = self; memset(&self, 0, sizeof(LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ)); return res; }
-	~CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ() { CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ_free(self); }
-	CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ& operator=(CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ&& o) { CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ)); return *this; }
-	LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ* operator &() { return &self; }
-	LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ* operator ->() { return &self; }
-	const LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ* operator &() const { return &self; }
-	const LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ* operator ->() const { return &self; }
-};
 class CResult_UntrustedStringDecodeErrorZ {
 private:
 	LDKCResult_UntrustedStringDecodeErrorZ self;
@@ -7136,20 +8843,20 @@ public:
 	const LDKCResult_UntrustedStringDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_UntrustedStringDecodeErrorZ* operator ->() const { return &self; }
 };
-class CVec_U5Z {
+class CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ {
 private:
-	LDKCVec_U5Z self;
+	LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ 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; }
+	CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ(const CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ&) = delete;
+	CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ(CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ)); }
+	CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ(LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ)); }
+	operator LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ() && { LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ)); return res; }
+	~CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ() { CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ_free(self); }
+	CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ& operator=(CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ&& o) { CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ)); return *this; }
+	LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ* operator &() { return &self; }
+	LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ* operator ->() { return &self; }
+	const LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ* operator &() const { return &self; }
+	const LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ* operator ->() const { return &self; }
 };
 class CResult_PaymentParametersDecodeErrorZ {
 private:
@@ -7166,6 +8873,21 @@ public:
 	const LDKCResult_PaymentParametersDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_PaymentParametersDecodeErrorZ* operator ->() const { return &self; }
 };
+class CResult_DelayedPaymentBasepointDecodeErrorZ {
+private:
+	LDKCResult_DelayedPaymentBasepointDecodeErrorZ self;
+public:
+	CResult_DelayedPaymentBasepointDecodeErrorZ(const CResult_DelayedPaymentBasepointDecodeErrorZ&) = delete;
+	CResult_DelayedPaymentBasepointDecodeErrorZ(CResult_DelayedPaymentBasepointDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_DelayedPaymentBasepointDecodeErrorZ)); }
+	CResult_DelayedPaymentBasepointDecodeErrorZ(LDKCResult_DelayedPaymentBasepointDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_DelayedPaymentBasepointDecodeErrorZ)); }
+	operator LDKCResult_DelayedPaymentBasepointDecodeErrorZ() && { LDKCResult_DelayedPaymentBasepointDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_DelayedPaymentBasepointDecodeErrorZ)); return res; }
+	~CResult_DelayedPaymentBasepointDecodeErrorZ() { CResult_DelayedPaymentBasepointDecodeErrorZ_free(self); }
+	CResult_DelayedPaymentBasepointDecodeErrorZ& operator=(CResult_DelayedPaymentBasepointDecodeErrorZ&& o) { CResult_DelayedPaymentBasepointDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_DelayedPaymentBasepointDecodeErrorZ)); return *this; }
+	LDKCResult_DelayedPaymentBasepointDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_DelayedPaymentBasepointDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_DelayedPaymentBasepointDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_DelayedPaymentBasepointDecodeErrorZ* operator ->() const { return &self; }
+};
 class C2Tuple_ThirtyTwoBytesChannelMonitorZ {
 private:
 	LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ self;
@@ -7211,6 +8933,21 @@ public:
 	const LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ* operator &() const { return &self; }
 	const LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ* operator ->() const { return &self; }
 };
+class CVec_MessageForwardNodeZ {
+private:
+	LDKCVec_MessageForwardNodeZ self;
+public:
+	CVec_MessageForwardNodeZ(const CVec_MessageForwardNodeZ&) = delete;
+	CVec_MessageForwardNodeZ(CVec_MessageForwardNodeZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_MessageForwardNodeZ)); }
+	CVec_MessageForwardNodeZ(LDKCVec_MessageForwardNodeZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_MessageForwardNodeZ)); }
+	operator LDKCVec_MessageForwardNodeZ() && { LDKCVec_MessageForwardNodeZ res = self; memset(&self, 0, sizeof(LDKCVec_MessageForwardNodeZ)); return res; }
+	~CVec_MessageForwardNodeZ() { CVec_MessageForwardNodeZ_free(self); }
+	CVec_MessageForwardNodeZ& operator=(CVec_MessageForwardNodeZ&& o) { CVec_MessageForwardNodeZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_MessageForwardNodeZ)); return *this; }
+	LDKCVec_MessageForwardNodeZ* operator &() { return &self; }
+	LDKCVec_MessageForwardNodeZ* operator ->() { return &self; }
+	const LDKCVec_MessageForwardNodeZ* operator &() const { return &self; }
+	const LDKCVec_MessageForwardNodeZ* operator ->() const { return &self; }
+};
 class CResult_TxAckRbfDecodeErrorZ {
 private:
 	LDKCResult_TxAckRbfDecodeErrorZ self;
@@ -7256,6 +8993,21 @@ public:
 	const LDKCOption_UtxoLookupZ* operator &() const { return &self; }
 	const LDKCOption_UtxoLookupZ* operator ->() const { return &self; }
 };
+class CResult__u832NoneZ {
+private:
+	LDKCResult__u832NoneZ self;
+public:
+	CResult__u832NoneZ(const CResult__u832NoneZ&) = delete;
+	CResult__u832NoneZ(CResult__u832NoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult__u832NoneZ)); }
+	CResult__u832NoneZ(LDKCResult__u832NoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult__u832NoneZ)); }
+	operator LDKCResult__u832NoneZ() && { LDKCResult__u832NoneZ res = self; memset(&self, 0, sizeof(LDKCResult__u832NoneZ)); return res; }
+	~CResult__u832NoneZ() { CResult__u832NoneZ_free(self); }
+	CResult__u832NoneZ& operator=(CResult__u832NoneZ&& o) { CResult__u832NoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult__u832NoneZ)); return *this; }
+	LDKCResult__u832NoneZ* operator &() { return &self; }
+	LDKCResult__u832NoneZ* operator ->() { return &self; }
+	const LDKCResult__u832NoneZ* operator &() const { return &self; }
+	const LDKCResult__u832NoneZ* operator ->() const { return &self; }
+};
 class CResult_PongDecodeErrorZ {
 private:
 	LDKCResult_PongDecodeErrorZ self;
@@ -7286,20 +9038,20 @@ public:
 	const LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator ->() const { return &self; }
 };
-class C2Tuple_OutPointCVec_MonitorUpdateIdZZ {
+class CResult_ChannelIdAPIErrorZ {
 private:
-	LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ self;
+	LDKCResult_ChannelIdAPIErrorZ self;
 public:
-	C2Tuple_OutPointCVec_MonitorUpdateIdZZ(const C2Tuple_OutPointCVec_MonitorUpdateIdZZ&) = delete;
-	C2Tuple_OutPointCVec_MonitorUpdateIdZZ(C2Tuple_OutPointCVec_MonitorUpdateIdZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_OutPointCVec_MonitorUpdateIdZZ)); }
-	C2Tuple_OutPointCVec_MonitorUpdateIdZZ(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ)); }
-	operator LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ() && { LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ)); return res; }
-	~C2Tuple_OutPointCVec_MonitorUpdateIdZZ() { C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free(self); }
-	C2Tuple_OutPointCVec_MonitorUpdateIdZZ& operator=(C2Tuple_OutPointCVec_MonitorUpdateIdZZ&& o) { C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_OutPointCVec_MonitorUpdateIdZZ)); return *this; }
-	LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* operator &() { return &self; }
-	LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* operator ->() { return &self; }
-	const LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* operator &() const { return &self; }
-	const LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* operator ->() const { return &self; }
+	CResult_ChannelIdAPIErrorZ(const CResult_ChannelIdAPIErrorZ&) = delete;
+	CResult_ChannelIdAPIErrorZ(CResult_ChannelIdAPIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelIdAPIErrorZ)); }
+	CResult_ChannelIdAPIErrorZ(LDKCResult_ChannelIdAPIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelIdAPIErrorZ)); }
+	operator LDKCResult_ChannelIdAPIErrorZ() && { LDKCResult_ChannelIdAPIErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelIdAPIErrorZ)); return res; }
+	~CResult_ChannelIdAPIErrorZ() { CResult_ChannelIdAPIErrorZ_free(self); }
+	CResult_ChannelIdAPIErrorZ& operator=(CResult_ChannelIdAPIErrorZ&& o) { CResult_ChannelIdAPIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelIdAPIErrorZ)); return *this; }
+	LDKCResult_ChannelIdAPIErrorZ* operator &() { return &self; }
+	LDKCResult_ChannelIdAPIErrorZ* operator ->() { return &self; }
+	const LDKCResult_ChannelIdAPIErrorZ* operator &() const { return &self; }
+	const LDKCResult_ChannelIdAPIErrorZ* operator ->() const { return &self; }
 };
 class CResult_CVec_u8ZNoneZ {
 private:
@@ -7316,6 +9068,21 @@ public:
 	const LDKCResult_CVec_u8ZNoneZ* operator &() const { return &self; }
 	const LDKCResult_CVec_u8ZNoneZ* operator ->() const { return &self; }
 };
+class CVec_C2Tuple_ChannelIdPublicKeyZZ {
+private:
+	LDKCVec_C2Tuple_ChannelIdPublicKeyZZ self;
+public:
+	CVec_C2Tuple_ChannelIdPublicKeyZZ(const CVec_C2Tuple_ChannelIdPublicKeyZZ&) = delete;
+	CVec_C2Tuple_ChannelIdPublicKeyZZ(CVec_C2Tuple_ChannelIdPublicKeyZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_ChannelIdPublicKeyZZ)); }
+	CVec_C2Tuple_ChannelIdPublicKeyZZ(LDKCVec_C2Tuple_ChannelIdPublicKeyZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_ChannelIdPublicKeyZZ)); }
+	operator LDKCVec_C2Tuple_ChannelIdPublicKeyZZ() && { LDKCVec_C2Tuple_ChannelIdPublicKeyZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_ChannelIdPublicKeyZZ)); return res; }
+	~CVec_C2Tuple_ChannelIdPublicKeyZZ() { CVec_C2Tuple_ChannelIdPublicKeyZZ_free(self); }
+	CVec_C2Tuple_ChannelIdPublicKeyZZ& operator=(CVec_C2Tuple_ChannelIdPublicKeyZZ&& o) { CVec_C2Tuple_ChannelIdPublicKeyZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_ChannelIdPublicKeyZZ)); return *this; }
+	LDKCVec_C2Tuple_ChannelIdPublicKeyZZ* operator &() { return &self; }
+	LDKCVec_C2Tuple_ChannelIdPublicKeyZZ* operator ->() { return &self; }
+	const LDKCVec_C2Tuple_ChannelIdPublicKeyZZ* operator &() const { return &self; }
+	const LDKCVec_C2Tuple_ChannelIdPublicKeyZZ* operator ->() const { return &self; }
+};
 class C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ {
 private:
 	LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ self;
@@ -7346,20 +9113,20 @@ public:
 	const LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_WriteableEcdsaChannelSignerDecodeErrorZ {
+class CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ {
 private:
-	LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ self;
+	LDKCResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ self;
 public:
-	CResult_WriteableEcdsaChannelSignerDecodeErrorZ(const CResult_WriteableEcdsaChannelSignerDecodeErrorZ&) = delete;
-	CResult_WriteableEcdsaChannelSignerDecodeErrorZ(CResult_WriteableEcdsaChannelSignerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_WriteableEcdsaChannelSignerDecodeErrorZ)); }
-	CResult_WriteableEcdsaChannelSignerDecodeErrorZ(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ)); }
-	operator LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ() && { LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ)); return res; }
-	~CResult_WriteableEcdsaChannelSignerDecodeErrorZ() { CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free(self); }
-	CResult_WriteableEcdsaChannelSignerDecodeErrorZ& operator=(CResult_WriteableEcdsaChannelSignerDecodeErrorZ&& o) { CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_WriteableEcdsaChannelSignerDecodeErrorZ)); return *this; }
-	LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* operator ->() const { return &self; }
+	CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ(const CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ&) = delete;
+	CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ(CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ)); }
+	CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ(LDKCResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ)); }
+	operator LDKCResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ() && { LDKCResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ)); return res; }
+	~CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ() { CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ_free(self); }
+	CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ& operator=(CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ&& o) { CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ)); return *this; }
+	LDKCResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ* operator &() { return &self; }
+	LDKCResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ* operator ->() { return &self; }
+	const LDKCResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ* operator &() const { return &self; }
+	const LDKCResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ* operator ->() const { return &self; }
 };
 class CResult_DelayedPaymentOutputDescriptorDecodeErrorZ {
 private:
@@ -7391,6 +9158,21 @@ public:
 	const LDKCResult_InFlightHtlcsDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_InFlightHtlcsDecodeErrorZ* operator ->() const { return &self; }
 };
+class CResult_CommitmentSignedBatchDecodeErrorZ {
+private:
+	LDKCResult_CommitmentSignedBatchDecodeErrorZ self;
+public:
+	CResult_CommitmentSignedBatchDecodeErrorZ(const CResult_CommitmentSignedBatchDecodeErrorZ&) = delete;
+	CResult_CommitmentSignedBatchDecodeErrorZ(CResult_CommitmentSignedBatchDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CommitmentSignedBatchDecodeErrorZ)); }
+	CResult_CommitmentSignedBatchDecodeErrorZ(LDKCResult_CommitmentSignedBatchDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CommitmentSignedBatchDecodeErrorZ)); }
+	operator LDKCResult_CommitmentSignedBatchDecodeErrorZ() && { LDKCResult_CommitmentSignedBatchDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CommitmentSignedBatchDecodeErrorZ)); return res; }
+	~CResult_CommitmentSignedBatchDecodeErrorZ() { CResult_CommitmentSignedBatchDecodeErrorZ_free(self); }
+	CResult_CommitmentSignedBatchDecodeErrorZ& operator=(CResult_CommitmentSignedBatchDecodeErrorZ&& o) { CResult_CommitmentSignedBatchDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CommitmentSignedBatchDecodeErrorZ)); return *this; }
+	LDKCResult_CommitmentSignedBatchDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_CommitmentSignedBatchDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_CommitmentSignedBatchDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_CommitmentSignedBatchDecodeErrorZ* operator ->() const { return &self; }
+};
 class CResult_COption_HTLCDestinationZDecodeErrorZ {
 private:
 	LDKCResult_COption_HTLCDestinationZDecodeErrorZ self;
@@ -7406,6 +9188,21 @@ public:
 	const LDKCResult_COption_HTLCDestinationZDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_COption_HTLCDestinationZDecodeErrorZ* operator ->() const { return &self; }
 };
+class CResult_Bolt12OfferContextDecodeErrorZ {
+private:
+	LDKCResult_Bolt12OfferContextDecodeErrorZ self;
+public:
+	CResult_Bolt12OfferContextDecodeErrorZ(const CResult_Bolt12OfferContextDecodeErrorZ&) = delete;
+	CResult_Bolt12OfferContextDecodeErrorZ(CResult_Bolt12OfferContextDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt12OfferContextDecodeErrorZ)); }
+	CResult_Bolt12OfferContextDecodeErrorZ(LDKCResult_Bolt12OfferContextDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt12OfferContextDecodeErrorZ)); }
+	operator LDKCResult_Bolt12OfferContextDecodeErrorZ() && { LDKCResult_Bolt12OfferContextDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt12OfferContextDecodeErrorZ)); return res; }
+	~CResult_Bolt12OfferContextDecodeErrorZ() { CResult_Bolt12OfferContextDecodeErrorZ_free(self); }
+	CResult_Bolt12OfferContextDecodeErrorZ& operator=(CResult_Bolt12OfferContextDecodeErrorZ&& o) { CResult_Bolt12OfferContextDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt12OfferContextDecodeErrorZ)); return *this; }
+	LDKCResult_Bolt12OfferContextDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_Bolt12OfferContextDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_Bolt12OfferContextDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_Bolt12OfferContextDecodeErrorZ* operator ->() const { return &self; }
+};
 class CResult_ThirtyTwoBytesNoneZ {
 private:
 	LDKCResult_ThirtyTwoBytesNoneZ self;
@@ -7421,21 +9218,6 @@ public:
 	const LDKCResult_ThirtyTwoBytesNoneZ* operator &() const { return &self; }
 	const LDKCResult_ThirtyTwoBytesNoneZ* operator ->() const { return &self; }
 };
-class C3Tuple_OnionMessageContentsDestinationBlindedPathZ {
-private:
-	LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ self;
-public:
-	C3Tuple_OnionMessageContentsDestinationBlindedPathZ(const C3Tuple_OnionMessageContentsDestinationBlindedPathZ&) = delete;
-	C3Tuple_OnionMessageContentsDestinationBlindedPathZ(C3Tuple_OnionMessageContentsDestinationBlindedPathZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_OnionMessageContentsDestinationBlindedPathZ)); }
-	C3Tuple_OnionMessageContentsDestinationBlindedPathZ(LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ)); }
-	operator LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ() && { LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ)); return res; }
-	~C3Tuple_OnionMessageContentsDestinationBlindedPathZ() { C3Tuple_OnionMessageContentsDestinationBlindedPathZ_free(self); }
-	C3Tuple_OnionMessageContentsDestinationBlindedPathZ& operator=(C3Tuple_OnionMessageContentsDestinationBlindedPathZ&& o) { C3Tuple_OnionMessageContentsDestinationBlindedPathZ_free(self); self = o.self; memset(&o, 0, sizeof(C3Tuple_OnionMessageContentsDestinationBlindedPathZ)); return *this; }
-	LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ* operator &() { return &self; }
-	LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ* operator ->() { return &self; }
-	const LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ* operator &() const { return &self; }
-	const LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ* operator ->() const { return &self; }
-};
 class C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ {
 private:
 	LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ self;
@@ -7451,20 +9233,50 @@ public:
 	const LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ* operator &() const { return &self; }
 	const LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ* operator ->() const { return &self; }
 };
-class CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ {
-private:
-	LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ self;
-public:
-	CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ(const CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ&) = delete;
-	CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ(CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ)); }
-	CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ(LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ)); }
-	operator LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ() && { LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ res = self; memset(&self, 0, sizeof(LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ)); return res; }
-	~CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ() { CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ_free(self); }
-	CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ& operator=(CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ&& o) { CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ)); return *this; }
-	LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ* operator &() { return &self; }
-	LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ* operator ->() { return &self; }
-	const LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ* operator &() const { return &self; }
-	const LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ* operator ->() const { return &self; }
+class CResult_SendSuccessSendErrorZ {
+private:
+	LDKCResult_SendSuccessSendErrorZ self;
+public:
+	CResult_SendSuccessSendErrorZ(const CResult_SendSuccessSendErrorZ&) = delete;
+	CResult_SendSuccessSendErrorZ(CResult_SendSuccessSendErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SendSuccessSendErrorZ)); }
+	CResult_SendSuccessSendErrorZ(LDKCResult_SendSuccessSendErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SendSuccessSendErrorZ)); }
+	operator LDKCResult_SendSuccessSendErrorZ() && { LDKCResult_SendSuccessSendErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SendSuccessSendErrorZ)); return res; }
+	~CResult_SendSuccessSendErrorZ() { CResult_SendSuccessSendErrorZ_free(self); }
+	CResult_SendSuccessSendErrorZ& operator=(CResult_SendSuccessSendErrorZ&& o) { CResult_SendSuccessSendErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SendSuccessSendErrorZ)); return *this; }
+	LDKCResult_SendSuccessSendErrorZ* operator &() { return &self; }
+	LDKCResult_SendSuccessSendErrorZ* operator ->() { return &self; }
+	const LDKCResult_SendSuccessSendErrorZ* operator &() const { return &self; }
+	const LDKCResult_SendSuccessSendErrorZ* operator ->() const { return &self; }
+};
+class CResult_NoneReplayEventZ {
+private:
+	LDKCResult_NoneReplayEventZ self;
+public:
+	CResult_NoneReplayEventZ(const CResult_NoneReplayEventZ&) = delete;
+	CResult_NoneReplayEventZ(CResult_NoneReplayEventZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneReplayEventZ)); }
+	CResult_NoneReplayEventZ(LDKCResult_NoneReplayEventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneReplayEventZ)); }
+	operator LDKCResult_NoneReplayEventZ() && { LDKCResult_NoneReplayEventZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneReplayEventZ)); return res; }
+	~CResult_NoneReplayEventZ() { CResult_NoneReplayEventZ_free(self); }
+	CResult_NoneReplayEventZ& operator=(CResult_NoneReplayEventZ&& o) { CResult_NoneReplayEventZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneReplayEventZ)); return *this; }
+	LDKCResult_NoneReplayEventZ* operator &() { return &self; }
+	LDKCResult_NoneReplayEventZ* operator ->() { return &self; }
+	const LDKCResult_NoneReplayEventZ* operator &() const { return &self; }
+	const LDKCResult_NoneReplayEventZ* operator ->() const { return &self; }
+};
+class C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ {
+private:
+	LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ self;
+public:
+	C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ(const C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ&) = delete;
+	C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ(C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ)); }
+	C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ(LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ)); }
+	operator LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ() && { LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ)); return res; }
+	~C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ() { C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_free(self); }
+	C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ& operator=(C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ&& o) { C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_free(self); self = o.self; memset(&o, 0, sizeof(C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ)); return *this; }
+	LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ* operator &() { return &self; }
+	LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ* operator ->() { return &self; }
+	const LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ* operator &() const { return &self; }
+	const LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ* operator ->() const { return &self; }
 };
 class CResult_BlindedHopDecodeErrorZ {
 private:
@@ -7481,20 +9293,20 @@ public:
 	const LDKCResult_BlindedHopDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_BlindedHopDecodeErrorZ* operator ->() const { return &self; }
 };
-class C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ {
+class CResult_NoneLightningErrorZ {
 private:
-	LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ self;
+	LDKCResult_NoneLightningErrorZ self;
 public:
-	C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ(const C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ&) = delete;
-	C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ(C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ)); }
-	C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ(LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ)); }
-	operator LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ() && { LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ)); return res; }
-	~C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ() { C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_free(self); }
-	C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ& operator=(C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ&& o) { C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ)); return *this; }
-	LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ* operator &() { return &self; }
-	LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ* operator ->() { return &self; }
-	const LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ* operator &() const { return &self; }
-	const LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ* operator ->() const { return &self; }
+	CResult_NoneLightningErrorZ(const CResult_NoneLightningErrorZ&) = delete;
+	CResult_NoneLightningErrorZ(CResult_NoneLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneLightningErrorZ)); }
+	CResult_NoneLightningErrorZ(LDKCResult_NoneLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneLightningErrorZ)); }
+	operator LDKCResult_NoneLightningErrorZ() && { LDKCResult_NoneLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneLightningErrorZ)); return res; }
+	~CResult_NoneLightningErrorZ() { CResult_NoneLightningErrorZ_free(self); }
+	CResult_NoneLightningErrorZ& operator=(CResult_NoneLightningErrorZ&& o) { CResult_NoneLightningErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneLightningErrorZ)); return *this; }
+	LDKCResult_NoneLightningErrorZ* operator &() { return &self; }
+	LDKCResult_NoneLightningErrorZ* operator ->() { return &self; }
+	const LDKCResult_NoneLightningErrorZ* operator &() const { return &self; }
+	const LDKCResult_NoneLightningErrorZ* operator ->() const { return &self; }
 };
 class CResult_FixedPenaltyScorerDecodeErrorZ {
 private:
@@ -7511,36 +9323,6 @@ public:
 	const LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator ->() const { return &self; }
 };
-class CVec_BlindedPathZ {
-private:
-	LDKCVec_BlindedPathZ self;
-public:
-	CVec_BlindedPathZ(const CVec_BlindedPathZ&) = delete;
-	CVec_BlindedPathZ(CVec_BlindedPathZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_BlindedPathZ)); }
-	CVec_BlindedPathZ(LDKCVec_BlindedPathZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_BlindedPathZ)); }
-	operator LDKCVec_BlindedPathZ() && { LDKCVec_BlindedPathZ res = self; memset(&self, 0, sizeof(LDKCVec_BlindedPathZ)); return res; }
-	~CVec_BlindedPathZ() { CVec_BlindedPathZ_free(self); }
-	CVec_BlindedPathZ& operator=(CVec_BlindedPathZ&& o) { CVec_BlindedPathZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_BlindedPathZ)); return *this; }
-	LDKCVec_BlindedPathZ* operator &() { return &self; }
-	LDKCVec_BlindedPathZ* operator ->() { return &self; }
-	const LDKCVec_BlindedPathZ* operator &() const { return &self; }
-	const LDKCVec_BlindedPathZ* operator ->() const { return &self; }
-};
-class CResult_NoneLightningErrorZ {
-private:
-	LDKCResult_NoneLightningErrorZ self;
-public:
-	CResult_NoneLightningErrorZ(const CResult_NoneLightningErrorZ&) = delete;
-	CResult_NoneLightningErrorZ(CResult_NoneLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneLightningErrorZ)); }
-	CResult_NoneLightningErrorZ(LDKCResult_NoneLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneLightningErrorZ)); }
-	operator LDKCResult_NoneLightningErrorZ() && { LDKCResult_NoneLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneLightningErrorZ)); return res; }
-	~CResult_NoneLightningErrorZ() { CResult_NoneLightningErrorZ_free(self); }
-	CResult_NoneLightningErrorZ& operator=(CResult_NoneLightningErrorZ&& o) { CResult_NoneLightningErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneLightningErrorZ)); return *this; }
-	LDKCResult_NoneLightningErrorZ* operator &() { return &self; }
-	LDKCResult_NoneLightningErrorZ* operator ->() { return &self; }
-	const LDKCResult_NoneLightningErrorZ* operator &() const { return &self; }
-	const LDKCResult_NoneLightningErrorZ* operator ->() const { return &self; }
-};
 class CResult_NonePeerHandleErrorZ {
 private:
 	LDKCResult_NonePeerHandleErrorZ self;
@@ -7571,6 +9353,21 @@ public:
 	const LDKCResult_TrustedCommitmentTransactionNoneZ* operator &() const { return &self; }
 	const LDKCResult_TrustedCommitmentTransactionNoneZ* operator ->() const { return &self; }
 };
+class CResult_FinalOnionHopDataDecodeErrorZ {
+private:
+	LDKCResult_FinalOnionHopDataDecodeErrorZ self;
+public:
+	CResult_FinalOnionHopDataDecodeErrorZ(const CResult_FinalOnionHopDataDecodeErrorZ&) = delete;
+	CResult_FinalOnionHopDataDecodeErrorZ(CResult_FinalOnionHopDataDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FinalOnionHopDataDecodeErrorZ)); }
+	CResult_FinalOnionHopDataDecodeErrorZ(LDKCResult_FinalOnionHopDataDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FinalOnionHopDataDecodeErrorZ)); }
+	operator LDKCResult_FinalOnionHopDataDecodeErrorZ() && { LDKCResult_FinalOnionHopDataDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FinalOnionHopDataDecodeErrorZ)); return res; }
+	~CResult_FinalOnionHopDataDecodeErrorZ() { CResult_FinalOnionHopDataDecodeErrorZ_free(self); }
+	CResult_FinalOnionHopDataDecodeErrorZ& operator=(CResult_FinalOnionHopDataDecodeErrorZ&& o) { CResult_FinalOnionHopDataDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FinalOnionHopDataDecodeErrorZ)); return *this; }
+	LDKCResult_FinalOnionHopDataDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_FinalOnionHopDataDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_FinalOnionHopDataDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_FinalOnionHopDataDecodeErrorZ* operator ->() const { return &self; }
+};
 class CResult_COption_EventZDecodeErrorZ {
 private:
 	LDKCResult_COption_EventZDecodeErrorZ self;
@@ -7586,36 +9383,6 @@ public:
 	const LDKCResult_COption_EventZDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_COption_EventZDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ {
-private:
-	LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ self;
-public:
-	CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ(const CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ&) = delete;
-	CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ(CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ)); }
-	CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ)); }
-	operator LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ() && { LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ)); return res; }
-	~CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ() { CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_free(self); }
-	CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ& operator=(CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ&& o) { CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ)); return *this; }
-	LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ* operator &() { return &self; }
-	LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ* operator ->() { return &self; }
-	const LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ* operator &() const { return &self; }
-	const LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ* operator ->() const { return &self; }
-};
-class CResult_PaymentFailureReasonDecodeErrorZ {
-private:
-	LDKCResult_PaymentFailureReasonDecodeErrorZ self;
-public:
-	CResult_PaymentFailureReasonDecodeErrorZ(const CResult_PaymentFailureReasonDecodeErrorZ&) = delete;
-	CResult_PaymentFailureReasonDecodeErrorZ(CResult_PaymentFailureReasonDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentFailureReasonDecodeErrorZ)); }
-	CResult_PaymentFailureReasonDecodeErrorZ(LDKCResult_PaymentFailureReasonDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentFailureReasonDecodeErrorZ)); }
-	operator LDKCResult_PaymentFailureReasonDecodeErrorZ() && { LDKCResult_PaymentFailureReasonDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentFailureReasonDecodeErrorZ)); return res; }
-	~CResult_PaymentFailureReasonDecodeErrorZ() { CResult_PaymentFailureReasonDecodeErrorZ_free(self); }
-	CResult_PaymentFailureReasonDecodeErrorZ& operator=(CResult_PaymentFailureReasonDecodeErrorZ&& o) { CResult_PaymentFailureReasonDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentFailureReasonDecodeErrorZ)); return *this; }
-	LDKCResult_PaymentFailureReasonDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_PaymentFailureReasonDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_PaymentFailureReasonDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_PaymentFailureReasonDecodeErrorZ* operator ->() const { return &self; }
-};
 class COption_SocketAddressZ {
 private:
 	LDKCOption_SocketAddressZ self;
@@ -7661,20 +9428,20 @@ public:
 	const LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ* operator &() const { return &self; }
 	const LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ* operator ->() const { return &self; }
 };
-class CResult_DescriptionCreationErrorZ {
+class CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ {
 private:
-	LDKCResult_DescriptionCreationErrorZ self;
+	LDKCResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ self;
 public:
-	CResult_DescriptionCreationErrorZ(const CResult_DescriptionCreationErrorZ&) = delete;
-	CResult_DescriptionCreationErrorZ(CResult_DescriptionCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_DescriptionCreationErrorZ)); }
-	CResult_DescriptionCreationErrorZ(LDKCResult_DescriptionCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_DescriptionCreationErrorZ)); }
-	operator LDKCResult_DescriptionCreationErrorZ() && { LDKCResult_DescriptionCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_DescriptionCreationErrorZ)); return res; }
-	~CResult_DescriptionCreationErrorZ() { CResult_DescriptionCreationErrorZ_free(self); }
-	CResult_DescriptionCreationErrorZ& operator=(CResult_DescriptionCreationErrorZ&& o) { CResult_DescriptionCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_DescriptionCreationErrorZ)); return *this; }
-	LDKCResult_DescriptionCreationErrorZ* operator &() { return &self; }
-	LDKCResult_DescriptionCreationErrorZ* operator ->() { return &self; }
-	const LDKCResult_DescriptionCreationErrorZ* operator &() const { return &self; }
-	const LDKCResult_DescriptionCreationErrorZ* operator ->() const { return &self; }
+	CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ(const CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ&) = delete;
+	CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ(CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ)); }
+	CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ(LDKCResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ)); }
+	operator LDKCResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ() && { LDKCResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ)); return res; }
+	~CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ() { CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ_free(self); }
+	CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ& operator=(CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ&& o) { CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ)); return *this; }
+	LDKCResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ* operator ->() const { return &self; }
 };
 class CResult_RoutingFeesDecodeErrorZ {
 private:
@@ -7706,6 +9473,21 @@ public:
 	const LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ* operator &() const { return &self; }
 	const LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ* operator ->() const { return &self; }
 };
+class CResult_DescriptionCreationErrorZ {
+private:
+	LDKCResult_DescriptionCreationErrorZ self;
+public:
+	CResult_DescriptionCreationErrorZ(const CResult_DescriptionCreationErrorZ&) = delete;
+	CResult_DescriptionCreationErrorZ(CResult_DescriptionCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_DescriptionCreationErrorZ)); }
+	CResult_DescriptionCreationErrorZ(LDKCResult_DescriptionCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_DescriptionCreationErrorZ)); }
+	operator LDKCResult_DescriptionCreationErrorZ() && { LDKCResult_DescriptionCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_DescriptionCreationErrorZ)); return res; }
+	~CResult_DescriptionCreationErrorZ() { CResult_DescriptionCreationErrorZ_free(self); }
+	CResult_DescriptionCreationErrorZ& operator=(CResult_DescriptionCreationErrorZ&& o) { CResult_DescriptionCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_DescriptionCreationErrorZ)); return *this; }
+	LDKCResult_DescriptionCreationErrorZ* operator &() { return &self; }
+	LDKCResult_DescriptionCreationErrorZ* operator ->() { return &self; }
+	const LDKCResult_DescriptionCreationErrorZ* operator &() const { return &self; }
+	const LDKCResult_DescriptionCreationErrorZ* operator ->() const { return &self; }
+};
 class CResult_PaymentRelayDecodeErrorZ {
 private:
 	LDKCResult_PaymentRelayDecodeErrorZ self;
@@ -7721,21 +9503,6 @@ public:
 	const LDKCResult_PaymentRelayDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_PaymentRelayDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ {
-private:
-	LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ self;
-public:
-	CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ(const CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ&) = delete;
-	CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ(CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ)); }
-	CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ(LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ)); }
-	operator LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ() && { LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ)); return res; }
-	~CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ() { CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_free(self); }
-	CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ& operator=(CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ&& o) { CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ)); return *this; }
-	LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ* operator &() { return &self; }
-	LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ* operator ->() { return &self; }
-	const LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ* operator &() const { return &self; }
-	const LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ* operator ->() const { return &self; }
-};
 class CResult_QueryShortChannelIdsDecodeErrorZ {
 private:
 	LDKCResult_QueryShortChannelIdsDecodeErrorZ self;
@@ -7781,6 +9548,21 @@ public:
 	const LDKCResult_UpdateAddHTLCDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_UpdateAddHTLCDecodeErrorZ* operator ->() const { return &self; }
 };
+class COption_OutboundHTLCStateDetailsZ {
+private:
+	LDKCOption_OutboundHTLCStateDetailsZ self;
+public:
+	COption_OutboundHTLCStateDetailsZ(const COption_OutboundHTLCStateDetailsZ&) = delete;
+	COption_OutboundHTLCStateDetailsZ(COption_OutboundHTLCStateDetailsZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_OutboundHTLCStateDetailsZ)); }
+	COption_OutboundHTLCStateDetailsZ(LDKCOption_OutboundHTLCStateDetailsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_OutboundHTLCStateDetailsZ)); }
+	operator LDKCOption_OutboundHTLCStateDetailsZ() && { LDKCOption_OutboundHTLCStateDetailsZ res = self; memset(&self, 0, sizeof(LDKCOption_OutboundHTLCStateDetailsZ)); return res; }
+	~COption_OutboundHTLCStateDetailsZ() { COption_OutboundHTLCStateDetailsZ_free(self); }
+	COption_OutboundHTLCStateDetailsZ& operator=(COption_OutboundHTLCStateDetailsZ&& o) { COption_OutboundHTLCStateDetailsZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_OutboundHTLCStateDetailsZ)); return *this; }
+	LDKCOption_OutboundHTLCStateDetailsZ* operator &() { return &self; }
+	LDKCOption_OutboundHTLCStateDetailsZ* operator ->() { return &self; }
+	const LDKCOption_OutboundHTLCStateDetailsZ* operator &() const { return &self; }
+	const LDKCOption_OutboundHTLCStateDetailsZ* operator ->() const { return &self; }
+};
 class COption_MonitorEventZ {
 private:
 	LDKCOption_MonitorEventZ self;
@@ -7826,6 +9608,21 @@ public:
 	const LDKCResult_COption_TypeZDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_COption_TypeZDecodeErrorZ* operator ->() const { return &self; }
 };
+class CResult_OfferDecodeErrorZ {
+private:
+	LDKCResult_OfferDecodeErrorZ self;
+public:
+	CResult_OfferDecodeErrorZ(const CResult_OfferDecodeErrorZ&) = delete;
+	CResult_OfferDecodeErrorZ(CResult_OfferDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OfferDecodeErrorZ)); }
+	CResult_OfferDecodeErrorZ(LDKCResult_OfferDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OfferDecodeErrorZ)); }
+	operator LDKCResult_OfferDecodeErrorZ() && { LDKCResult_OfferDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OfferDecodeErrorZ)); return res; }
+	~CResult_OfferDecodeErrorZ() { CResult_OfferDecodeErrorZ_free(self); }
+	CResult_OfferDecodeErrorZ& operator=(CResult_OfferDecodeErrorZ&& o) { CResult_OfferDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OfferDecodeErrorZ)); return *this; }
+	LDKCResult_OfferDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_OfferDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_OfferDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_OfferDecodeErrorZ* operator ->() const { return &self; }
+};
 class CResult_COption_PathFailureZDecodeErrorZ {
 private:
 	LDKCResult_COption_PathFailureZDecodeErrorZ self;
@@ -7856,6 +9653,21 @@ public:
 	const LDKCResult_Bolt11InvoiceSignOrCreationErrorZ* operator &() const { return &self; }
 	const LDKCResult_Bolt11InvoiceSignOrCreationErrorZ* operator ->() const { return &self; }
 };
+class CResult_BlindedMessagePathNoneZ {
+private:
+	LDKCResult_BlindedMessagePathNoneZ self;
+public:
+	CResult_BlindedMessagePathNoneZ(const CResult_BlindedMessagePathNoneZ&) = delete;
+	CResult_BlindedMessagePathNoneZ(CResult_BlindedMessagePathNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedMessagePathNoneZ)); }
+	CResult_BlindedMessagePathNoneZ(LDKCResult_BlindedMessagePathNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedMessagePathNoneZ)); }
+	operator LDKCResult_BlindedMessagePathNoneZ() && { LDKCResult_BlindedMessagePathNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedMessagePathNoneZ)); return res; }
+	~CResult_BlindedMessagePathNoneZ() { CResult_BlindedMessagePathNoneZ_free(self); }
+	CResult_BlindedMessagePathNoneZ& operator=(CResult_BlindedMessagePathNoneZ&& o) { CResult_BlindedMessagePathNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedMessagePathNoneZ)); return *this; }
+	LDKCResult_BlindedMessagePathNoneZ* operator &() { return &self; }
+	LDKCResult_BlindedMessagePathNoneZ* operator ->() { return &self; }
+	const LDKCResult_BlindedMessagePathNoneZ* operator &() const { return &self; }
+	const LDKCResult_BlindedMessagePathNoneZ* operator ->() const { return &self; }
+};
 class CResult_UpdateFailHTLCDecodeErrorZ {
 private:
 	LDKCResult_UpdateFailHTLCDecodeErrorZ self;
@@ -7871,6 +9683,36 @@ public:
 	const LDKCResult_UpdateFailHTLCDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_UpdateFailHTLCDecodeErrorZ* operator ->() const { return &self; }
 };
+class CResult_BlindedPaymentPathNoneZ {
+private:
+	LDKCResult_BlindedPaymentPathNoneZ self;
+public:
+	CResult_BlindedPaymentPathNoneZ(const CResult_BlindedPaymentPathNoneZ&) = delete;
+	CResult_BlindedPaymentPathNoneZ(CResult_BlindedPaymentPathNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedPaymentPathNoneZ)); }
+	CResult_BlindedPaymentPathNoneZ(LDKCResult_BlindedPaymentPathNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedPaymentPathNoneZ)); }
+	operator LDKCResult_BlindedPaymentPathNoneZ() && { LDKCResult_BlindedPaymentPathNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedPaymentPathNoneZ)); return res; }
+	~CResult_BlindedPaymentPathNoneZ() { CResult_BlindedPaymentPathNoneZ_free(self); }
+	CResult_BlindedPaymentPathNoneZ& operator=(CResult_BlindedPaymentPathNoneZ&& o) { CResult_BlindedPaymentPathNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedPaymentPathNoneZ)); return *this; }
+	LDKCResult_BlindedPaymentPathNoneZ* operator &() { return &self; }
+	LDKCResult_BlindedPaymentPathNoneZ* operator ->() { return &self; }
+	const LDKCResult_BlindedPaymentPathNoneZ* operator &() const { return &self; }
+	const LDKCResult_BlindedPaymentPathNoneZ* operator ->() const { return &self; }
+};
+class CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ {
+private:
+	LDKCResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ self;
+public:
+	CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ(const CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ&) = delete;
+	CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ(CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ)); }
+	CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ(LDKCResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ)); }
+	operator LDKCResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ() && { LDKCResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ)); return res; }
+	~CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ() { CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ_free(self); }
+	CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ& operator=(CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ&& o) { CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ)); return *this; }
+	LDKCResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ* operator &() { return &self; }
+	LDKCResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ* operator ->() { return &self; }
+	const LDKCResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ* operator &() const { return &self; }
+	const LDKCResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ* operator ->() const { return &self; }
+};
 class CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ {
 private:
 	LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ self;
@@ -7886,21 +9728,6 @@ public:
 	const LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ* operator &() const { return &self; }
 	const LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ* operator ->() const { return &self; }
 };
-class CResult_RevokeAndACKDecodeErrorZ {
-private:
-	LDKCResult_RevokeAndACKDecodeErrorZ self;
-public:
-	CResult_RevokeAndACKDecodeErrorZ(const CResult_RevokeAndACKDecodeErrorZ&) = delete;
-	CResult_RevokeAndACKDecodeErrorZ(CResult_RevokeAndACKDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RevokeAndACKDecodeErrorZ)); }
-	CResult_RevokeAndACKDecodeErrorZ(LDKCResult_RevokeAndACKDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RevokeAndACKDecodeErrorZ)); }
-	operator LDKCResult_RevokeAndACKDecodeErrorZ() && { LDKCResult_RevokeAndACKDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RevokeAndACKDecodeErrorZ)); return res; }
-	~CResult_RevokeAndACKDecodeErrorZ() { CResult_RevokeAndACKDecodeErrorZ_free(self); }
-	CResult_RevokeAndACKDecodeErrorZ& operator=(CResult_RevokeAndACKDecodeErrorZ&& o) { CResult_RevokeAndACKDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RevokeAndACKDecodeErrorZ)); return *this; }
-	LDKCResult_RevokeAndACKDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_RevokeAndACKDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_RevokeAndACKDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_RevokeAndACKDecodeErrorZ* operator ->() const { return &self; }
-};
 class CResult_SpendableOutputDescriptorDecodeErrorZ {
 private:
 	LDKCResult_SpendableOutputDescriptorDecodeErrorZ self;
@@ -7916,20 +9743,20 @@ public:
 	const LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator ->() const { return &self; }
 };
-class C2Tuple_PublicKeyCOption_SocketAddressZZ {
+class CResult_RevokeAndACKDecodeErrorZ {
 private:
-	LDKC2Tuple_PublicKeyCOption_SocketAddressZZ self;
+	LDKCResult_RevokeAndACKDecodeErrorZ self;
 public:
-	C2Tuple_PublicKeyCOption_SocketAddressZZ(const C2Tuple_PublicKeyCOption_SocketAddressZZ&) = delete;
-	C2Tuple_PublicKeyCOption_SocketAddressZZ(C2Tuple_PublicKeyCOption_SocketAddressZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_PublicKeyCOption_SocketAddressZZ)); }
-	C2Tuple_PublicKeyCOption_SocketAddressZZ(LDKC2Tuple_PublicKeyCOption_SocketAddressZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_PublicKeyCOption_SocketAddressZZ)); }
-	operator LDKC2Tuple_PublicKeyCOption_SocketAddressZZ() && { LDKC2Tuple_PublicKeyCOption_SocketAddressZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_PublicKeyCOption_SocketAddressZZ)); return res; }
-	~C2Tuple_PublicKeyCOption_SocketAddressZZ() { C2Tuple_PublicKeyCOption_SocketAddressZZ_free(self); }
-	C2Tuple_PublicKeyCOption_SocketAddressZZ& operator=(C2Tuple_PublicKeyCOption_SocketAddressZZ&& o) { C2Tuple_PublicKeyCOption_SocketAddressZZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_PublicKeyCOption_SocketAddressZZ)); return *this; }
-	LDKC2Tuple_PublicKeyCOption_SocketAddressZZ* operator &() { return &self; }
-	LDKC2Tuple_PublicKeyCOption_SocketAddressZZ* operator ->() { return &self; }
-	const LDKC2Tuple_PublicKeyCOption_SocketAddressZZ* operator &() const { return &self; }
-	const LDKC2Tuple_PublicKeyCOption_SocketAddressZZ* operator ->() const { return &self; }
+	CResult_RevokeAndACKDecodeErrorZ(const CResult_RevokeAndACKDecodeErrorZ&) = delete;
+	CResult_RevokeAndACKDecodeErrorZ(CResult_RevokeAndACKDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RevokeAndACKDecodeErrorZ)); }
+	CResult_RevokeAndACKDecodeErrorZ(LDKCResult_RevokeAndACKDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RevokeAndACKDecodeErrorZ)); }
+	operator LDKCResult_RevokeAndACKDecodeErrorZ() && { LDKCResult_RevokeAndACKDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RevokeAndACKDecodeErrorZ)); return res; }
+	~CResult_RevokeAndACKDecodeErrorZ() { CResult_RevokeAndACKDecodeErrorZ_free(self); }
+	CResult_RevokeAndACKDecodeErrorZ& operator=(CResult_RevokeAndACKDecodeErrorZ&& o) { CResult_RevokeAndACKDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RevokeAndACKDecodeErrorZ)); return *this; }
+	LDKCResult_RevokeAndACKDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_RevokeAndACKDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_RevokeAndACKDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_RevokeAndACKDecodeErrorZ* operator ->() const { return &self; }
 };
 class CResult_UnsignedChannelUpdateDecodeErrorZ {
 private:
@@ -7961,6 +9788,51 @@ public:
 	const LDKCResult_PayeePubKeySecp256k1ErrorZ* operator &() const { return &self; }
 	const LDKCResult_PayeePubKeySecp256k1ErrorZ* operator ->() const { return &self; }
 };
+class C2Tuple__u832u16Z {
+private:
+	LDKC2Tuple__u832u16Z self;
+public:
+	C2Tuple__u832u16Z(const C2Tuple__u832u16Z&) = delete;
+	C2Tuple__u832u16Z(C2Tuple__u832u16Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple__u832u16Z)); }
+	C2Tuple__u832u16Z(LDKC2Tuple__u832u16Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple__u832u16Z)); }
+	operator LDKC2Tuple__u832u16Z() && { LDKC2Tuple__u832u16Z res = self; memset(&self, 0, sizeof(LDKC2Tuple__u832u16Z)); return res; }
+	~C2Tuple__u832u16Z() { C2Tuple__u832u16Z_free(self); }
+	C2Tuple__u832u16Z& operator=(C2Tuple__u832u16Z&& o) { C2Tuple__u832u16Z_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple__u832u16Z)); return *this; }
+	LDKC2Tuple__u832u16Z* operator &() { return &self; }
+	LDKC2Tuple__u832u16Z* operator ->() { return &self; }
+	const LDKC2Tuple__u832u16Z* operator &() const { return &self; }
+	const LDKC2Tuple__u832u16Z* operator ->() const { return &self; }
+};
+class CResult_BlindedMessagePathDecodeErrorZ {
+private:
+	LDKCResult_BlindedMessagePathDecodeErrorZ self;
+public:
+	CResult_BlindedMessagePathDecodeErrorZ(const CResult_BlindedMessagePathDecodeErrorZ&) = delete;
+	CResult_BlindedMessagePathDecodeErrorZ(CResult_BlindedMessagePathDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedMessagePathDecodeErrorZ)); }
+	CResult_BlindedMessagePathDecodeErrorZ(LDKCResult_BlindedMessagePathDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedMessagePathDecodeErrorZ)); }
+	operator LDKCResult_BlindedMessagePathDecodeErrorZ() && { LDKCResult_BlindedMessagePathDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedMessagePathDecodeErrorZ)); return res; }
+	~CResult_BlindedMessagePathDecodeErrorZ() { CResult_BlindedMessagePathDecodeErrorZ_free(self); }
+	CResult_BlindedMessagePathDecodeErrorZ& operator=(CResult_BlindedMessagePathDecodeErrorZ&& o) { CResult_BlindedMessagePathDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedMessagePathDecodeErrorZ)); return *this; }
+	LDKCResult_BlindedMessagePathDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_BlindedMessagePathDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_BlindedMessagePathDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_BlindedMessagePathDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_CVec_BlindedMessagePathZNoneZ {
+private:
+	LDKCResult_CVec_BlindedMessagePathZNoneZ self;
+public:
+	CResult_CVec_BlindedMessagePathZNoneZ(const CResult_CVec_BlindedMessagePathZNoneZ&) = delete;
+	CResult_CVec_BlindedMessagePathZNoneZ(CResult_CVec_BlindedMessagePathZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_BlindedMessagePathZNoneZ)); }
+	CResult_CVec_BlindedMessagePathZNoneZ(LDKCResult_CVec_BlindedMessagePathZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_BlindedMessagePathZNoneZ)); }
+	operator LDKCResult_CVec_BlindedMessagePathZNoneZ() && { LDKCResult_CVec_BlindedMessagePathZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_BlindedMessagePathZNoneZ)); return res; }
+	~CResult_CVec_BlindedMessagePathZNoneZ() { CResult_CVec_BlindedMessagePathZNoneZ_free(self); }
+	CResult_CVec_BlindedMessagePathZNoneZ& operator=(CResult_CVec_BlindedMessagePathZNoneZ&& o) { CResult_CVec_BlindedMessagePathZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_BlindedMessagePathZNoneZ)); return *this; }
+	LDKCResult_CVec_BlindedMessagePathZNoneZ* operator &() { return &self; }
+	LDKCResult_CVec_BlindedMessagePathZNoneZ* operator ->() { return &self; }
+	const LDKCResult_CVec_BlindedMessagePathZNoneZ* operator &() const { return &self; }
+	const LDKCResult_CVec_BlindedMessagePathZNoneZ* operator ->() const { return &self; }
+};
 class COption_BigEndianScalarZ {
 private:
 	LDKCOption_BigEndianScalarZ self;
@@ -7976,6 +9848,21 @@ public:
 	const LDKCOption_BigEndianScalarZ* operator &() const { return &self; }
 	const LDKCOption_BigEndianScalarZ* operator ->() const { return &self; }
 };
+class CVec_ChannelIdZ {
+private:
+	LDKCVec_ChannelIdZ self;
+public:
+	CVec_ChannelIdZ(const CVec_ChannelIdZ&) = delete;
+	CVec_ChannelIdZ(CVec_ChannelIdZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ChannelIdZ)); }
+	CVec_ChannelIdZ(LDKCVec_ChannelIdZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ChannelIdZ)); }
+	operator LDKCVec_ChannelIdZ() && { LDKCVec_ChannelIdZ res = self; memset(&self, 0, sizeof(LDKCVec_ChannelIdZ)); return res; }
+	~CVec_ChannelIdZ() { CVec_ChannelIdZ_free(self); }
+	CVec_ChannelIdZ& operator=(CVec_ChannelIdZ&& o) { CVec_ChannelIdZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ChannelIdZ)); return *this; }
+	LDKCVec_ChannelIdZ* operator &() { return &self; }
+	LDKCVec_ChannelIdZ* operator ->() { return &self; }
+	const LDKCVec_ChannelIdZ* operator &() const { return &self; }
+	const LDKCVec_ChannelIdZ* operator ->() const { return &self; }
+};
 class CResult_PublicKeySecp256k1ErrorZ {
 private:
 	LDKCResult_PublicKeySecp256k1ErrorZ self;
@@ -7991,20 +9878,20 @@ public:
 	const LDKCResult_PublicKeySecp256k1ErrorZ* operator &() const { return &self; }
 	const LDKCResult_PublicKeySecp256k1ErrorZ* operator ->() const { return &self; }
 };
-class CResult_CVec_ECDSASignatureZNoneZ {
+class C2Tuple_OnionMessageContentsMessageSendInstructionsZ {
 private:
-	LDKCResult_CVec_ECDSASignatureZNoneZ self;
+	LDKC2Tuple_OnionMessageContentsMessageSendInstructionsZ self;
 public:
-	CResult_CVec_ECDSASignatureZNoneZ(const CResult_CVec_ECDSASignatureZNoneZ&) = delete;
-	CResult_CVec_ECDSASignatureZNoneZ(CResult_CVec_ECDSASignatureZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_ECDSASignatureZNoneZ)); }
-	CResult_CVec_ECDSASignatureZNoneZ(LDKCResult_CVec_ECDSASignatureZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_ECDSASignatureZNoneZ)); }
-	operator LDKCResult_CVec_ECDSASignatureZNoneZ() && { LDKCResult_CVec_ECDSASignatureZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_ECDSASignatureZNoneZ)); return res; }
-	~CResult_CVec_ECDSASignatureZNoneZ() { CResult_CVec_ECDSASignatureZNoneZ_free(self); }
-	CResult_CVec_ECDSASignatureZNoneZ& operator=(CResult_CVec_ECDSASignatureZNoneZ&& o) { CResult_CVec_ECDSASignatureZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_ECDSASignatureZNoneZ)); return *this; }
-	LDKCResult_CVec_ECDSASignatureZNoneZ* operator &() { return &self; }
-	LDKCResult_CVec_ECDSASignatureZNoneZ* operator ->() { return &self; }
-	const LDKCResult_CVec_ECDSASignatureZNoneZ* operator &() const { return &self; }
-	const LDKCResult_CVec_ECDSASignatureZNoneZ* operator ->() const { return &self; }
+	C2Tuple_OnionMessageContentsMessageSendInstructionsZ(const C2Tuple_OnionMessageContentsMessageSendInstructionsZ&) = delete;
+	C2Tuple_OnionMessageContentsMessageSendInstructionsZ(C2Tuple_OnionMessageContentsMessageSendInstructionsZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_OnionMessageContentsMessageSendInstructionsZ)); }
+	C2Tuple_OnionMessageContentsMessageSendInstructionsZ(LDKC2Tuple_OnionMessageContentsMessageSendInstructionsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_OnionMessageContentsMessageSendInstructionsZ)); }
+	operator LDKC2Tuple_OnionMessageContentsMessageSendInstructionsZ() && { LDKC2Tuple_OnionMessageContentsMessageSendInstructionsZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_OnionMessageContentsMessageSendInstructionsZ)); return res; }
+	~C2Tuple_OnionMessageContentsMessageSendInstructionsZ() { C2Tuple_OnionMessageContentsMessageSendInstructionsZ_free(self); }
+	C2Tuple_OnionMessageContentsMessageSendInstructionsZ& operator=(C2Tuple_OnionMessageContentsMessageSendInstructionsZ&& o) { C2Tuple_OnionMessageContentsMessageSendInstructionsZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_OnionMessageContentsMessageSendInstructionsZ)); return *this; }
+	LDKC2Tuple_OnionMessageContentsMessageSendInstructionsZ* operator &() { return &self; }
+	LDKC2Tuple_OnionMessageContentsMessageSendInstructionsZ* operator ->() { return &self; }
+	const LDKC2Tuple_OnionMessageContentsMessageSendInstructionsZ* operator &() const { return &self; }
+	const LDKC2Tuple_OnionMessageContentsMessageSendInstructionsZ* operator ->() const { return &self; }
 };
 class CVec_BlindedHopZ {
 private:
@@ -8021,6 +9908,36 @@ public:
 	const LDKCVec_BlindedHopZ* operator &() const { return &self; }
 	const LDKCVec_BlindedHopZ* operator ->() const { return &self; }
 };
+class CResult_ReleaseHeldHtlcDecodeErrorZ {
+private:
+	LDKCResult_ReleaseHeldHtlcDecodeErrorZ self;
+public:
+	CResult_ReleaseHeldHtlcDecodeErrorZ(const CResult_ReleaseHeldHtlcDecodeErrorZ&) = delete;
+	CResult_ReleaseHeldHtlcDecodeErrorZ(CResult_ReleaseHeldHtlcDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ReleaseHeldHtlcDecodeErrorZ)); }
+	CResult_ReleaseHeldHtlcDecodeErrorZ(LDKCResult_ReleaseHeldHtlcDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ReleaseHeldHtlcDecodeErrorZ)); }
+	operator LDKCResult_ReleaseHeldHtlcDecodeErrorZ() && { LDKCResult_ReleaseHeldHtlcDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ReleaseHeldHtlcDecodeErrorZ)); return res; }
+	~CResult_ReleaseHeldHtlcDecodeErrorZ() { CResult_ReleaseHeldHtlcDecodeErrorZ_free(self); }
+	CResult_ReleaseHeldHtlcDecodeErrorZ& operator=(CResult_ReleaseHeldHtlcDecodeErrorZ&& o) { CResult_ReleaseHeldHtlcDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ReleaseHeldHtlcDecodeErrorZ)); return *this; }
+	LDKCResult_ReleaseHeldHtlcDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_ReleaseHeldHtlcDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_ReleaseHeldHtlcDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_ReleaseHeldHtlcDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_CVec_ECDSASignatureZNoneZ {
+private:
+	LDKCResult_CVec_ECDSASignatureZNoneZ self;
+public:
+	CResult_CVec_ECDSASignatureZNoneZ(const CResult_CVec_ECDSASignatureZNoneZ&) = delete;
+	CResult_CVec_ECDSASignatureZNoneZ(CResult_CVec_ECDSASignatureZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_ECDSASignatureZNoneZ)); }
+	CResult_CVec_ECDSASignatureZNoneZ(LDKCResult_CVec_ECDSASignatureZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_ECDSASignatureZNoneZ)); }
+	operator LDKCResult_CVec_ECDSASignatureZNoneZ() && { LDKCResult_CVec_ECDSASignatureZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_ECDSASignatureZNoneZ)); return res; }
+	~CResult_CVec_ECDSASignatureZNoneZ() { CResult_CVec_ECDSASignatureZNoneZ_free(self); }
+	CResult_CVec_ECDSASignatureZNoneZ& operator=(CResult_CVec_ECDSASignatureZNoneZ&& o) { CResult_CVec_ECDSASignatureZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_ECDSASignatureZNoneZ)); return *this; }
+	LDKCResult_CVec_ECDSASignatureZNoneZ* operator &() { return &self; }
+	LDKCResult_CVec_ECDSASignatureZNoneZ* operator ->() { return &self; }
+	const LDKCResult_CVec_ECDSASignatureZNoneZ* operator &() const { return &self; }
+	const LDKCResult_CVec_ECDSASignatureZNoneZ* operator ->() const { return &self; }
+};
 class CResult_COption_ClosureReasonZDecodeErrorZ {
 private:
 	LDKCResult_COption_ClosureReasonZDecodeErrorZ self;
@@ -8036,21 +9953,6 @@ public:
 	const LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_InvoiceErrorDecodeErrorZ {
-private:
-	LDKCResult_InvoiceErrorDecodeErrorZ self;
-public:
-	CResult_InvoiceErrorDecodeErrorZ(const CResult_InvoiceErrorDecodeErrorZ&) = delete;
-	CResult_InvoiceErrorDecodeErrorZ(CResult_InvoiceErrorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceErrorDecodeErrorZ)); }
-	CResult_InvoiceErrorDecodeErrorZ(LDKCResult_InvoiceErrorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceErrorDecodeErrorZ)); }
-	operator LDKCResult_InvoiceErrorDecodeErrorZ() && { LDKCResult_InvoiceErrorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceErrorDecodeErrorZ)); return res; }
-	~CResult_InvoiceErrorDecodeErrorZ() { CResult_InvoiceErrorDecodeErrorZ_free(self); }
-	CResult_InvoiceErrorDecodeErrorZ& operator=(CResult_InvoiceErrorDecodeErrorZ&& o) { CResult_InvoiceErrorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceErrorDecodeErrorZ)); return *this; }
-	LDKCResult_InvoiceErrorDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_InvoiceErrorDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_InvoiceErrorDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_InvoiceErrorDecodeErrorZ* operator ->() const { return &self; }
-};
 class C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ {
 private:
 	LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ self;
@@ -8066,6 +9968,21 @@ public:
 	const LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator &() const { return &self; }
 	const LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator ->() const { return &self; }
 };
+class CResult_NonceDecodeErrorZ {
+private:
+	LDKCResult_NonceDecodeErrorZ self;
+public:
+	CResult_NonceDecodeErrorZ(const CResult_NonceDecodeErrorZ&) = delete;
+	CResult_NonceDecodeErrorZ(CResult_NonceDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NonceDecodeErrorZ)); }
+	CResult_NonceDecodeErrorZ(LDKCResult_NonceDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NonceDecodeErrorZ)); }
+	operator LDKCResult_NonceDecodeErrorZ() && { LDKCResult_NonceDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NonceDecodeErrorZ)); return res; }
+	~CResult_NonceDecodeErrorZ() { CResult_NonceDecodeErrorZ_free(self); }
+	CResult_NonceDecodeErrorZ& operator=(CResult_NonceDecodeErrorZ&& o) { CResult_NonceDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NonceDecodeErrorZ)); return *this; }
+	LDKCResult_NonceDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_NonceDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_NonceDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_NonceDecodeErrorZ* operator ->() const { return &self; }
+};
 class CResult_RouteParametersDecodeErrorZ {
 private:
 	LDKCResult_RouteParametersDecodeErrorZ self;
@@ -8096,6 +10013,21 @@ public:
 	const LDKCResult_PrivateRouteCreationErrorZ* operator &() const { return &self; }
 	const LDKCResult_PrivateRouteCreationErrorZ* operator ->() const { return &self; }
 };
+class CResult_InvoiceErrorDecodeErrorZ {
+private:
+	LDKCResult_InvoiceErrorDecodeErrorZ self;
+public:
+	CResult_InvoiceErrorDecodeErrorZ(const CResult_InvoiceErrorDecodeErrorZ&) = delete;
+	CResult_InvoiceErrorDecodeErrorZ(CResult_InvoiceErrorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceErrorDecodeErrorZ)); }
+	CResult_InvoiceErrorDecodeErrorZ(LDKCResult_InvoiceErrorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceErrorDecodeErrorZ)); }
+	operator LDKCResult_InvoiceErrorDecodeErrorZ() && { LDKCResult_InvoiceErrorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceErrorDecodeErrorZ)); return res; }
+	~CResult_InvoiceErrorDecodeErrorZ() { CResult_InvoiceErrorDecodeErrorZ_free(self); }
+	CResult_InvoiceErrorDecodeErrorZ& operator=(CResult_InvoiceErrorDecodeErrorZ&& o) { CResult_InvoiceErrorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceErrorDecodeErrorZ)); return *this; }
+	LDKCResult_InvoiceErrorDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_InvoiceErrorDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_InvoiceErrorDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_InvoiceErrorDecodeErrorZ* operator ->() const { return &self; }
+};
 class CResult_NodeAliasDecodeErrorZ {
 private:
 	LDKCResult_NodeAliasDecodeErrorZ self;
@@ -8111,6 +10043,36 @@ public:
 	const LDKCResult_NodeAliasDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_NodeAliasDecodeErrorZ* operator ->() const { return &self; }
 };
+class C2Tuple_BestBlockOutputSweeperZ {
+private:
+	LDKC2Tuple_BestBlockOutputSweeperZ self;
+public:
+	C2Tuple_BestBlockOutputSweeperZ(const C2Tuple_BestBlockOutputSweeperZ&) = delete;
+	C2Tuple_BestBlockOutputSweeperZ(C2Tuple_BestBlockOutputSweeperZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_BestBlockOutputSweeperZ)); }
+	C2Tuple_BestBlockOutputSweeperZ(LDKC2Tuple_BestBlockOutputSweeperZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_BestBlockOutputSweeperZ)); }
+	operator LDKC2Tuple_BestBlockOutputSweeperZ() && { LDKC2Tuple_BestBlockOutputSweeperZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_BestBlockOutputSweeperZ)); return res; }
+	~C2Tuple_BestBlockOutputSweeperZ() { C2Tuple_BestBlockOutputSweeperZ_free(self); }
+	C2Tuple_BestBlockOutputSweeperZ& operator=(C2Tuple_BestBlockOutputSweeperZ&& o) { C2Tuple_BestBlockOutputSweeperZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_BestBlockOutputSweeperZ)); return *this; }
+	LDKC2Tuple_BestBlockOutputSweeperZ* operator &() { return &self; }
+	LDKC2Tuple_BestBlockOutputSweeperZ* operator ->() { return &self; }
+	const LDKC2Tuple_BestBlockOutputSweeperZ* operator &() const { return &self; }
+	const LDKC2Tuple_BestBlockOutputSweeperZ* operator ->() const { return &self; }
+};
+class C2Tuple_OutPointCVec_u64ZZ {
+private:
+	LDKC2Tuple_OutPointCVec_u64ZZ self;
+public:
+	C2Tuple_OutPointCVec_u64ZZ(const C2Tuple_OutPointCVec_u64ZZ&) = delete;
+	C2Tuple_OutPointCVec_u64ZZ(C2Tuple_OutPointCVec_u64ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_OutPointCVec_u64ZZ)); }
+	C2Tuple_OutPointCVec_u64ZZ(LDKC2Tuple_OutPointCVec_u64ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_OutPointCVec_u64ZZ)); }
+	operator LDKC2Tuple_OutPointCVec_u64ZZ() && { LDKC2Tuple_OutPointCVec_u64ZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_OutPointCVec_u64ZZ)); return res; }
+	~C2Tuple_OutPointCVec_u64ZZ() { C2Tuple_OutPointCVec_u64ZZ_free(self); }
+	C2Tuple_OutPointCVec_u64ZZ& operator=(C2Tuple_OutPointCVec_u64ZZ&& o) { C2Tuple_OutPointCVec_u64ZZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_OutPointCVec_u64ZZ)); return *this; }
+	LDKC2Tuple_OutPointCVec_u64ZZ* operator &() { return &self; }
+	LDKC2Tuple_OutPointCVec_u64ZZ* operator ->() { return &self; }
+	const LDKC2Tuple_OutPointCVec_u64ZZ* operator &() const { return &self; }
+	const LDKC2Tuple_OutPointCVec_u64ZZ* operator ->() const { return &self; }
+};
 class CVec_UpdateFulfillHTLCZ {
 private:
 	LDKCVec_UpdateFulfillHTLCZ self;
@@ -8141,6 +10103,21 @@ public:
 	const LDKCVec_C2Tuple_u32CVec_u8ZZZ* operator &() const { return &self; }
 	const LDKCVec_C2Tuple_u32CVec_u8ZZZ* operator ->() const { return &self; }
 };
+class C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ {
+private:
+	LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ self;
+public:
+	C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ(const C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ&) = delete;
+	C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ(C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ)); }
+	C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ(LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ)); }
+	operator LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ() && { LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ)); return res; }
+	~C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ() { C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_free(self); }
+	C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ& operator=(C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ&& o) { C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_free(self); self = o.self; memset(&o, 0, sizeof(C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ)); return *this; }
+	LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ* operator &() { return &self; }
+	LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ* operator ->() { return &self; }
+	const LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ* operator &() const { return &self; }
+	const LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ* operator ->() const { return &self; }
+};
 class CResult_AnnouncementSignaturesDecodeErrorZ {
 private:
 	LDKCResult_AnnouncementSignaturesDecodeErrorZ self;
@@ -8156,21 +10133,6 @@ public:
 	const LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_UpdateFulfillHTLCDecodeErrorZ {
-private:
-	LDKCResult_UpdateFulfillHTLCDecodeErrorZ self;
-public:
-	CResult_UpdateFulfillHTLCDecodeErrorZ(const CResult_UpdateFulfillHTLCDecodeErrorZ&) = delete;
-	CResult_UpdateFulfillHTLCDecodeErrorZ(CResult_UpdateFulfillHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateFulfillHTLCDecodeErrorZ)); }
-	CResult_UpdateFulfillHTLCDecodeErrorZ(LDKCResult_UpdateFulfillHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ)); }
-	operator LDKCResult_UpdateFulfillHTLCDecodeErrorZ() && { LDKCResult_UpdateFulfillHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ)); return res; }
-	~CResult_UpdateFulfillHTLCDecodeErrorZ() { CResult_UpdateFulfillHTLCDecodeErrorZ_free(self); }
-	CResult_UpdateFulfillHTLCDecodeErrorZ& operator=(CResult_UpdateFulfillHTLCDecodeErrorZ&& o) { CResult_UpdateFulfillHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateFulfillHTLCDecodeErrorZ)); return *this; }
-	LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator ->() const { return &self; }
-};
 class CResult_TxCompleteDecodeErrorZ {
 private:
 	LDKCResult_TxCompleteDecodeErrorZ self;
@@ -8186,20 +10148,20 @@ public:
 	const LDKCResult_TxCompleteDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_TxCompleteDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_StrSecp256k1ErrorZ {
+class CResult_UpdateFulfillHTLCDecodeErrorZ {
 private:
-	LDKCResult_StrSecp256k1ErrorZ self;
+	LDKCResult_UpdateFulfillHTLCDecodeErrorZ self;
 public:
-	CResult_StrSecp256k1ErrorZ(const CResult_StrSecp256k1ErrorZ&) = delete;
-	CResult_StrSecp256k1ErrorZ(CResult_StrSecp256k1ErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_StrSecp256k1ErrorZ)); }
-	CResult_StrSecp256k1ErrorZ(LDKCResult_StrSecp256k1ErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_StrSecp256k1ErrorZ)); }
-	operator LDKCResult_StrSecp256k1ErrorZ() && { LDKCResult_StrSecp256k1ErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_StrSecp256k1ErrorZ)); return res; }
-	~CResult_StrSecp256k1ErrorZ() { CResult_StrSecp256k1ErrorZ_free(self); }
-	CResult_StrSecp256k1ErrorZ& operator=(CResult_StrSecp256k1ErrorZ&& o) { CResult_StrSecp256k1ErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_StrSecp256k1ErrorZ)); return *this; }
-	LDKCResult_StrSecp256k1ErrorZ* operator &() { return &self; }
-	LDKCResult_StrSecp256k1ErrorZ* operator ->() { return &self; }
-	const LDKCResult_StrSecp256k1ErrorZ* operator &() const { return &self; }
-	const LDKCResult_StrSecp256k1ErrorZ* operator ->() const { return &self; }
+	CResult_UpdateFulfillHTLCDecodeErrorZ(const CResult_UpdateFulfillHTLCDecodeErrorZ&) = delete;
+	CResult_UpdateFulfillHTLCDecodeErrorZ(CResult_UpdateFulfillHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateFulfillHTLCDecodeErrorZ)); }
+	CResult_UpdateFulfillHTLCDecodeErrorZ(LDKCResult_UpdateFulfillHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ)); }
+	operator LDKCResult_UpdateFulfillHTLCDecodeErrorZ() && { LDKCResult_UpdateFulfillHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ)); return res; }
+	~CResult_UpdateFulfillHTLCDecodeErrorZ() { CResult_UpdateFulfillHTLCDecodeErrorZ_free(self); }
+	CResult_UpdateFulfillHTLCDecodeErrorZ& operator=(CResult_UpdateFulfillHTLCDecodeErrorZ&& o) { CResult_UpdateFulfillHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateFulfillHTLCDecodeErrorZ)); return *this; }
+	LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator ->() const { return &self; }
 };
 class CResult_NodeFeaturesDecodeErrorZ {
 private:
@@ -8291,6 +10253,21 @@ public:
 	const LDKCOption_PathFailureZ* operator &() const { return &self; }
 	const LDKCOption_PathFailureZ* operator ->() const { return &self; }
 };
+class COption_MessageContextZ {
+private:
+	LDKCOption_MessageContextZ self;
+public:
+	COption_MessageContextZ(const COption_MessageContextZ&) = delete;
+	COption_MessageContextZ(COption_MessageContextZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_MessageContextZ)); }
+	COption_MessageContextZ(LDKCOption_MessageContextZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_MessageContextZ)); }
+	operator LDKCOption_MessageContextZ() && { LDKCOption_MessageContextZ res = self; memset(&self, 0, sizeof(LDKCOption_MessageContextZ)); return res; }
+	~COption_MessageContextZ() { COption_MessageContextZ_free(self); }
+	COption_MessageContextZ& operator=(COption_MessageContextZ&& o) { COption_MessageContextZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_MessageContextZ)); return *this; }
+	LDKCOption_MessageContextZ* operator &() { return &self; }
+	LDKCOption_MessageContextZ* operator ->() { return &self; }
+	const LDKCOption_MessageContextZ* operator &() const { return &self; }
+	const LDKCOption_MessageContextZ* operator ->() const { return &self; }
+};
 class CVec_ECDSASignatureZ {
 private:
 	LDKCVec_ECDSASignatureZ self;
@@ -8351,6 +10328,36 @@ public:
 	const LDKCVec_TxOutZ* operator &() const { return &self; }
 	const LDKCVec_TxOutZ* operator ->() const { return &self; }
 };
+class CVec_InboundHTLCDetailsZ {
+private:
+	LDKCVec_InboundHTLCDetailsZ self;
+public:
+	CVec_InboundHTLCDetailsZ(const CVec_InboundHTLCDetailsZ&) = delete;
+	CVec_InboundHTLCDetailsZ(CVec_InboundHTLCDetailsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_InboundHTLCDetailsZ)); }
+	CVec_InboundHTLCDetailsZ(LDKCVec_InboundHTLCDetailsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_InboundHTLCDetailsZ)); }
+	operator LDKCVec_InboundHTLCDetailsZ() && { LDKCVec_InboundHTLCDetailsZ res = self; memset(&self, 0, sizeof(LDKCVec_InboundHTLCDetailsZ)); return res; }
+	~CVec_InboundHTLCDetailsZ() { CVec_InboundHTLCDetailsZ_free(self); }
+	CVec_InboundHTLCDetailsZ& operator=(CVec_InboundHTLCDetailsZ&& o) { CVec_InboundHTLCDetailsZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_InboundHTLCDetailsZ)); return *this; }
+	LDKCVec_InboundHTLCDetailsZ* operator &() { return &self; }
+	LDKCVec_InboundHTLCDetailsZ* operator ->() { return &self; }
+	const LDKCVec_InboundHTLCDetailsZ* operator &() const { return &self; }
+	const LDKCVec_InboundHTLCDetailsZ* operator ->() const { return &self; }
+};
+class CVec_OutboundHTLCDetailsZ {
+private:
+	LDKCVec_OutboundHTLCDetailsZ self;
+public:
+	CVec_OutboundHTLCDetailsZ(const CVec_OutboundHTLCDetailsZ&) = delete;
+	CVec_OutboundHTLCDetailsZ(CVec_OutboundHTLCDetailsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_OutboundHTLCDetailsZ)); }
+	CVec_OutboundHTLCDetailsZ(LDKCVec_OutboundHTLCDetailsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_OutboundHTLCDetailsZ)); }
+	operator LDKCVec_OutboundHTLCDetailsZ() && { LDKCVec_OutboundHTLCDetailsZ res = self; memset(&self, 0, sizeof(LDKCVec_OutboundHTLCDetailsZ)); return res; }
+	~CVec_OutboundHTLCDetailsZ() { CVec_OutboundHTLCDetailsZ_free(self); }
+	CVec_OutboundHTLCDetailsZ& operator=(CVec_OutboundHTLCDetailsZ&& o) { CVec_OutboundHTLCDetailsZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_OutboundHTLCDetailsZ)); return *this; }
+	LDKCVec_OutboundHTLCDetailsZ* operator &() { return &self; }
+	LDKCVec_OutboundHTLCDetailsZ* operator ->() { return &self; }
+	const LDKCVec_OutboundHTLCDetailsZ* operator &() const { return &self; }
+	const LDKCVec_OutboundHTLCDetailsZ* operator ->() const { return &self; }
+};
 class CResult_BuiltCommitmentTransactionDecodeErrorZ {
 private:
 	LDKCResult_BuiltCommitmentTransactionDecodeErrorZ self;
@@ -8366,6 +10373,36 @@ public:
 	const LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator ->() const { return &self; }
 };
+class CVec_PaymentForwardNodeZ {
+private:
+	LDKCVec_PaymentForwardNodeZ self;
+public:
+	CVec_PaymentForwardNodeZ(const CVec_PaymentForwardNodeZ&) = delete;
+	CVec_PaymentForwardNodeZ(CVec_PaymentForwardNodeZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PaymentForwardNodeZ)); }
+	CVec_PaymentForwardNodeZ(LDKCVec_PaymentForwardNodeZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PaymentForwardNodeZ)); }
+	operator LDKCVec_PaymentForwardNodeZ() && { LDKCVec_PaymentForwardNodeZ res = self; memset(&self, 0, sizeof(LDKCVec_PaymentForwardNodeZ)); return res; }
+	~CVec_PaymentForwardNodeZ() { CVec_PaymentForwardNodeZ_free(self); }
+	CVec_PaymentForwardNodeZ& operator=(CVec_PaymentForwardNodeZ&& o) { CVec_PaymentForwardNodeZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PaymentForwardNodeZ)); return *this; }
+	LDKCVec_PaymentForwardNodeZ* operator &() { return &self; }
+	LDKCVec_PaymentForwardNodeZ* operator ->() { return &self; }
+	const LDKCVec_PaymentForwardNodeZ* operator &() const { return &self; }
+	const LDKCVec_PaymentForwardNodeZ* operator ->() const { return &self; }
+};
+class CResult_TrackedSpendableOutputDecodeErrorZ {
+private:
+	LDKCResult_TrackedSpendableOutputDecodeErrorZ self;
+public:
+	CResult_TrackedSpendableOutputDecodeErrorZ(const CResult_TrackedSpendableOutputDecodeErrorZ&) = delete;
+	CResult_TrackedSpendableOutputDecodeErrorZ(CResult_TrackedSpendableOutputDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TrackedSpendableOutputDecodeErrorZ)); }
+	CResult_TrackedSpendableOutputDecodeErrorZ(LDKCResult_TrackedSpendableOutputDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TrackedSpendableOutputDecodeErrorZ)); }
+	operator LDKCResult_TrackedSpendableOutputDecodeErrorZ() && { LDKCResult_TrackedSpendableOutputDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TrackedSpendableOutputDecodeErrorZ)); return res; }
+	~CResult_TrackedSpendableOutputDecodeErrorZ() { CResult_TrackedSpendableOutputDecodeErrorZ_free(self); }
+	CResult_TrackedSpendableOutputDecodeErrorZ& operator=(CResult_TrackedSpendableOutputDecodeErrorZ&& o) { CResult_TrackedSpendableOutputDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TrackedSpendableOutputDecodeErrorZ)); return *this; }
+	LDKCResult_TrackedSpendableOutputDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_TrackedSpendableOutputDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_TrackedSpendableOutputDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_TrackedSpendableOutputDecodeErrorZ* operator ->() const { return &self; }
+};
 class CVec_SpendableOutputDescriptorZ {
 private:
 	LDKCVec_SpendableOutputDescriptorZ self;
@@ -8381,6 +10418,21 @@ public:
 	const LDKCVec_SpendableOutputDescriptorZ* operator &() const { return &self; }
 	const LDKCVec_SpendableOutputDescriptorZ* operator ->() const { return &self; }
 };
+class CResult_ResponderDecodeErrorZ {
+private:
+	LDKCResult_ResponderDecodeErrorZ self;
+public:
+	CResult_ResponderDecodeErrorZ(const CResult_ResponderDecodeErrorZ&) = delete;
+	CResult_ResponderDecodeErrorZ(CResult_ResponderDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ResponderDecodeErrorZ)); }
+	CResult_ResponderDecodeErrorZ(LDKCResult_ResponderDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ResponderDecodeErrorZ)); }
+	operator LDKCResult_ResponderDecodeErrorZ() && { LDKCResult_ResponderDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ResponderDecodeErrorZ)); return res; }
+	~CResult_ResponderDecodeErrorZ() { CResult_ResponderDecodeErrorZ_free(self); }
+	CResult_ResponderDecodeErrorZ& operator=(CResult_ResponderDecodeErrorZ&& o) { CResult_ResponderDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ResponderDecodeErrorZ)); return *this; }
+	LDKCResult_ResponderDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_ResponderDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_ResponderDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_ResponderDecodeErrorZ* operator ->() const { return &self; }
+};
 class C2Tuple_OutPointCVec_u8ZZ {
 private:
 	LDKC2Tuple_OutPointCVec_u8ZZ self;
@@ -8396,6 +10448,21 @@ public:
 	const LDKC2Tuple_OutPointCVec_u8ZZ* operator &() const { return &self; }
 	const LDKC2Tuple_OutPointCVec_u8ZZ* operator ->() const { return &self; }
 };
+class CResult_WitnessNoneZ {
+private:
+	LDKCResult_WitnessNoneZ self;
+public:
+	CResult_WitnessNoneZ(const CResult_WitnessNoneZ&) = delete;
+	CResult_WitnessNoneZ(CResult_WitnessNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_WitnessNoneZ)); }
+	CResult_WitnessNoneZ(LDKCResult_WitnessNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_WitnessNoneZ)); }
+	operator LDKCResult_WitnessNoneZ() && { LDKCResult_WitnessNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_WitnessNoneZ)); return res; }
+	~CResult_WitnessNoneZ() { CResult_WitnessNoneZ_free(self); }
+	CResult_WitnessNoneZ& operator=(CResult_WitnessNoneZ&& o) { CResult_WitnessNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_WitnessNoneZ)); return *this; }
+	LDKCResult_WitnessNoneZ* operator &() { return &self; }
+	LDKCResult_WitnessNoneZ* operator ->() { return &self; }
+	const LDKCResult_WitnessNoneZ* operator &() const { return &self; }
+	const LDKCResult_WitnessNoneZ* operator ->() const { return &self; }
+};
 class COption_C2Tuple_u64u64ZZ {
 private:
 	LDKCOption_C2Tuple_u64u64ZZ self;
@@ -8426,21 +10493,6 @@ public:
 	const LDKCResult_ChannelAnnouncementDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_ChannelAnnouncementDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_PeeledOnionNoneZ {
-private:
-	LDKCResult_PeeledOnionNoneZ self;
-public:
-	CResult_PeeledOnionNoneZ(const CResult_PeeledOnionNoneZ&) = delete;
-	CResult_PeeledOnionNoneZ(CResult_PeeledOnionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PeeledOnionNoneZ)); }
-	CResult_PeeledOnionNoneZ(LDKCResult_PeeledOnionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PeeledOnionNoneZ)); }
-	operator LDKCResult_PeeledOnionNoneZ() && { LDKCResult_PeeledOnionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_PeeledOnionNoneZ)); return res; }
-	~CResult_PeeledOnionNoneZ() { CResult_PeeledOnionNoneZ_free(self); }
-	CResult_PeeledOnionNoneZ& operator=(CResult_PeeledOnionNoneZ&& o) { CResult_PeeledOnionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PeeledOnionNoneZ)); return *this; }
-	LDKCResult_PeeledOnionNoneZ* operator &() { return &self; }
-	LDKCResult_PeeledOnionNoneZ* operator ->() { return &self; }
-	const LDKCResult_PeeledOnionNoneZ* operator &() const { return &self; }
-	const LDKCResult_PeeledOnionNoneZ* operator ->() const { return &self; }
-};
 class CResult_HTLCUpdateDecodeErrorZ {
 private:
 	LDKCResult_HTLCUpdateDecodeErrorZ self;
@@ -8471,20 +10523,20 @@ public:
 	const LDKCResult_TxAddInputDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_TxAddInputDecodeErrorZ* operator ->() const { return &self; }
 };
-class CVec_OutPointZ {
+class CResult_HeldHtlcAvailableDecodeErrorZ {
 private:
-	LDKCVec_OutPointZ self;
+	LDKCResult_HeldHtlcAvailableDecodeErrorZ self;
 public:
-	CVec_OutPointZ(const CVec_OutPointZ&) = delete;
-	CVec_OutPointZ(CVec_OutPointZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_OutPointZ)); }
-	CVec_OutPointZ(LDKCVec_OutPointZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_OutPointZ)); }
-	operator LDKCVec_OutPointZ() && { LDKCVec_OutPointZ res = self; memset(&self, 0, sizeof(LDKCVec_OutPointZ)); return res; }
-	~CVec_OutPointZ() { CVec_OutPointZ_free(self); }
-	CVec_OutPointZ& operator=(CVec_OutPointZ&& o) { CVec_OutPointZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_OutPointZ)); return *this; }
-	LDKCVec_OutPointZ* operator &() { return &self; }
-	LDKCVec_OutPointZ* operator ->() { return &self; }
-	const LDKCVec_OutPointZ* operator &() const { return &self; }
-	const LDKCVec_OutPointZ* operator ->() const { return &self; }
+	CResult_HeldHtlcAvailableDecodeErrorZ(const CResult_HeldHtlcAvailableDecodeErrorZ&) = delete;
+	CResult_HeldHtlcAvailableDecodeErrorZ(CResult_HeldHtlcAvailableDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HeldHtlcAvailableDecodeErrorZ)); }
+	CResult_HeldHtlcAvailableDecodeErrorZ(LDKCResult_HeldHtlcAvailableDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HeldHtlcAvailableDecodeErrorZ)); }
+	operator LDKCResult_HeldHtlcAvailableDecodeErrorZ() && { LDKCResult_HeldHtlcAvailableDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HeldHtlcAvailableDecodeErrorZ)); return res; }
+	~CResult_HeldHtlcAvailableDecodeErrorZ() { CResult_HeldHtlcAvailableDecodeErrorZ_free(self); }
+	CResult_HeldHtlcAvailableDecodeErrorZ& operator=(CResult_HeldHtlcAvailableDecodeErrorZ&& o) { CResult_HeldHtlcAvailableDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HeldHtlcAvailableDecodeErrorZ)); return *this; }
+	LDKCResult_HeldHtlcAvailableDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_HeldHtlcAvailableDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_HeldHtlcAvailableDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_HeldHtlcAvailableDecodeErrorZ* operator ->() const { return &self; }
 };
 class CResult_TxInitRbfDecodeErrorZ {
 private:
@@ -8531,6 +10583,36 @@ public:
 	const LDKCVec_StrZ* operator &() const { return &self; }
 	const LDKCVec_StrZ* operator ->() const { return &self; }
 };
+class CResult_AsyncPaymentsMessageDecodeErrorZ {
+private:
+	LDKCResult_AsyncPaymentsMessageDecodeErrorZ self;
+public:
+	CResult_AsyncPaymentsMessageDecodeErrorZ(const CResult_AsyncPaymentsMessageDecodeErrorZ&) = delete;
+	CResult_AsyncPaymentsMessageDecodeErrorZ(CResult_AsyncPaymentsMessageDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_AsyncPaymentsMessageDecodeErrorZ)); }
+	CResult_AsyncPaymentsMessageDecodeErrorZ(LDKCResult_AsyncPaymentsMessageDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_AsyncPaymentsMessageDecodeErrorZ)); }
+	operator LDKCResult_AsyncPaymentsMessageDecodeErrorZ() && { LDKCResult_AsyncPaymentsMessageDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_AsyncPaymentsMessageDecodeErrorZ)); return res; }
+	~CResult_AsyncPaymentsMessageDecodeErrorZ() { CResult_AsyncPaymentsMessageDecodeErrorZ_free(self); }
+	CResult_AsyncPaymentsMessageDecodeErrorZ& operator=(CResult_AsyncPaymentsMessageDecodeErrorZ&& o) { CResult_AsyncPaymentsMessageDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_AsyncPaymentsMessageDecodeErrorZ)); return *this; }
+	LDKCResult_AsyncPaymentsMessageDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_AsyncPaymentsMessageDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_AsyncPaymentsMessageDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_AsyncPaymentsMessageDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_SpliceAckDecodeErrorZ {
+private:
+	LDKCResult_SpliceAckDecodeErrorZ self;
+public:
+	CResult_SpliceAckDecodeErrorZ(const CResult_SpliceAckDecodeErrorZ&) = delete;
+	CResult_SpliceAckDecodeErrorZ(CResult_SpliceAckDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SpliceAckDecodeErrorZ)); }
+	CResult_SpliceAckDecodeErrorZ(LDKCResult_SpliceAckDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SpliceAckDecodeErrorZ)); }
+	operator LDKCResult_SpliceAckDecodeErrorZ() && { LDKCResult_SpliceAckDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SpliceAckDecodeErrorZ)); return res; }
+	~CResult_SpliceAckDecodeErrorZ() { CResult_SpliceAckDecodeErrorZ_free(self); }
+	CResult_SpliceAckDecodeErrorZ& operator=(CResult_SpliceAckDecodeErrorZ&& o) { CResult_SpliceAckDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SpliceAckDecodeErrorZ)); return *this; }
+	LDKCResult_SpliceAckDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_SpliceAckDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_SpliceAckDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_SpliceAckDecodeErrorZ* operator ->() const { return &self; }
+};
 class CResult_PositiveTimestampCreationErrorZ {
 private:
 	LDKCResult_PositiveTimestampCreationErrorZ self;
@@ -8546,6 +10628,36 @@ public:
 	const LDKCResult_PositiveTimestampCreationErrorZ* operator &() const { return &self; }
 	const LDKCResult_PositiveTimestampCreationErrorZ* operator ->() const { return &self; }
 };
+class CResult_PeeledOnionNoneZ {
+private:
+	LDKCResult_PeeledOnionNoneZ self;
+public:
+	CResult_PeeledOnionNoneZ(const CResult_PeeledOnionNoneZ&) = delete;
+	CResult_PeeledOnionNoneZ(CResult_PeeledOnionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PeeledOnionNoneZ)); }
+	CResult_PeeledOnionNoneZ(LDKCResult_PeeledOnionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PeeledOnionNoneZ)); }
+	operator LDKCResult_PeeledOnionNoneZ() && { LDKCResult_PeeledOnionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_PeeledOnionNoneZ)); return res; }
+	~CResult_PeeledOnionNoneZ() { CResult_PeeledOnionNoneZ_free(self); }
+	CResult_PeeledOnionNoneZ& operator=(CResult_PeeledOnionNoneZ&& o) { CResult_PeeledOnionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PeeledOnionNoneZ)); return *this; }
+	LDKCResult_PeeledOnionNoneZ* operator &() { return &self; }
+	LDKCResult_PeeledOnionNoneZ* operator ->() { return &self; }
+	const LDKCResult_PeeledOnionNoneZ* operator &() const { return &self; }
+	const LDKCResult_PeeledOnionNoneZ* operator ->() const { return &self; }
+};
+class CVec_C2Tuple_OutPointChannelIdZZ {
+private:
+	LDKCVec_C2Tuple_OutPointChannelIdZZ self;
+public:
+	CVec_C2Tuple_OutPointChannelIdZZ(const CVec_C2Tuple_OutPointChannelIdZZ&) = delete;
+	CVec_C2Tuple_OutPointChannelIdZZ(CVec_C2Tuple_OutPointChannelIdZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_OutPointChannelIdZZ)); }
+	CVec_C2Tuple_OutPointChannelIdZZ(LDKCVec_C2Tuple_OutPointChannelIdZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_OutPointChannelIdZZ)); }
+	operator LDKCVec_C2Tuple_OutPointChannelIdZZ() && { LDKCVec_C2Tuple_OutPointChannelIdZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_OutPointChannelIdZZ)); return res; }
+	~CVec_C2Tuple_OutPointChannelIdZZ() { CVec_C2Tuple_OutPointChannelIdZZ_free(self); }
+	CVec_C2Tuple_OutPointChannelIdZZ& operator=(CVec_C2Tuple_OutPointChannelIdZZ&& o) { CVec_C2Tuple_OutPointChannelIdZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_OutPointChannelIdZZ)); return *this; }
+	LDKCVec_C2Tuple_OutPointChannelIdZZ* operator &() { return &self; }
+	LDKCVec_C2Tuple_OutPointChannelIdZZ* operator ->() { return &self; }
+	const LDKCVec_C2Tuple_OutPointChannelIdZZ* operator &() const { return &self; }
+	const LDKCVec_C2Tuple_OutPointChannelIdZZ* operator ->() const { return &self; }
+};
 class CResult_ChannelMonitorUpdateDecodeErrorZ {
 private:
 	LDKCResult_ChannelMonitorUpdateDecodeErrorZ self;
@@ -8561,21 +10673,6 @@ public:
 	const LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator ->() const { return &self; }
 };
-class C2Tuple_BlindedPayInfoBlindedPathZ {
-private:
-	LDKC2Tuple_BlindedPayInfoBlindedPathZ self;
-public:
-	C2Tuple_BlindedPayInfoBlindedPathZ(const C2Tuple_BlindedPayInfoBlindedPathZ&) = delete;
-	C2Tuple_BlindedPayInfoBlindedPathZ(C2Tuple_BlindedPayInfoBlindedPathZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_BlindedPayInfoBlindedPathZ)); }
-	C2Tuple_BlindedPayInfoBlindedPathZ(LDKC2Tuple_BlindedPayInfoBlindedPathZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_BlindedPayInfoBlindedPathZ)); }
-	operator LDKC2Tuple_BlindedPayInfoBlindedPathZ() && { LDKC2Tuple_BlindedPayInfoBlindedPathZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_BlindedPayInfoBlindedPathZ)); return res; }
-	~C2Tuple_BlindedPayInfoBlindedPathZ() { C2Tuple_BlindedPayInfoBlindedPathZ_free(self); }
-	C2Tuple_BlindedPayInfoBlindedPathZ& operator=(C2Tuple_BlindedPayInfoBlindedPathZ&& o) { C2Tuple_BlindedPayInfoBlindedPathZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_BlindedPayInfoBlindedPathZ)); return *this; }
-	LDKC2Tuple_BlindedPayInfoBlindedPathZ* operator &() { return &self; }
-	LDKC2Tuple_BlindedPayInfoBlindedPathZ* operator ->() { return &self; }
-	const LDKC2Tuple_BlindedPayInfoBlindedPathZ* operator &() const { return &self; }
-	const LDKC2Tuple_BlindedPayInfoBlindedPathZ* operator ->() const { return &self; }
-};
 class CResult_ReplyChannelRangeDecodeErrorZ {
 private:
 	LDKCResult_ReplyChannelRangeDecodeErrorZ self;
@@ -8696,36 +10793,6 @@ public:
 	const LDKCResult_OnionMessageDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_OnionMessageDecodeErrorZ* operator ->() const { return &self; }
 };
-class CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ {
-private:
-	LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ self;
-public:
-	CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ(const CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ&) = delete;
-	CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ(CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ)); }
-	CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ(LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ)); }
-	operator LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ() && { LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ)); return res; }
-	~CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ() { CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ_free(self); }
-	CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ& operator=(CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ&& o) { CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ)); return *this; }
-	LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ* operator &() { return &self; }
-	LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ* operator ->() { return &self; }
-	const LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ* operator &() const { return &self; }
-	const LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ* operator ->() const { return &self; }
-};
-class CResult_C2Tuple_CVec_u8ZusizeZNoneZ {
-private:
-	LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ self;
-public:
-	CResult_C2Tuple_CVec_u8ZusizeZNoneZ(const CResult_C2Tuple_CVec_u8ZusizeZNoneZ&) = delete;
-	CResult_C2Tuple_CVec_u8ZusizeZNoneZ(CResult_C2Tuple_CVec_u8ZusizeZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_CVec_u8ZusizeZNoneZ)); }
-	CResult_C2Tuple_CVec_u8ZusizeZNoneZ(LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ)); }
-	operator LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ() && { LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ)); return res; }
-	~CResult_C2Tuple_CVec_u8ZusizeZNoneZ() { CResult_C2Tuple_CVec_u8ZusizeZNoneZ_free(self); }
-	CResult_C2Tuple_CVec_u8ZusizeZNoneZ& operator=(CResult_C2Tuple_CVec_u8ZusizeZNoneZ&& o) { CResult_C2Tuple_CVec_u8ZusizeZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_CVec_u8ZusizeZNoneZ)); return *this; }
-	LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ* operator &() { return &self; }
-	LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ* operator ->() { return &self; }
-	const LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ* operator &() const { return &self; }
-	const LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ* operator ->() const { return &self; }
-};
 class CResult_Bolt11InvoiceParseOrSemanticErrorZ {
 private:
 	LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ self;
@@ -8741,6 +10808,21 @@ public:
 	const LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ* operator &() const { return &self; }
 	const LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ* operator ->() const { return &self; }
 };
+class CResult_MessageContextDecodeErrorZ {
+private:
+	LDKCResult_MessageContextDecodeErrorZ self;
+public:
+	CResult_MessageContextDecodeErrorZ(const CResult_MessageContextDecodeErrorZ&) = delete;
+	CResult_MessageContextDecodeErrorZ(CResult_MessageContextDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_MessageContextDecodeErrorZ)); }
+	CResult_MessageContextDecodeErrorZ(LDKCResult_MessageContextDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_MessageContextDecodeErrorZ)); }
+	operator LDKCResult_MessageContextDecodeErrorZ() && { LDKCResult_MessageContextDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_MessageContextDecodeErrorZ)); return res; }
+	~CResult_MessageContextDecodeErrorZ() { CResult_MessageContextDecodeErrorZ_free(self); }
+	CResult_MessageContextDecodeErrorZ& operator=(CResult_MessageContextDecodeErrorZ&& o) { CResult_MessageContextDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_MessageContextDecodeErrorZ)); return *this; }
+	LDKCResult_MessageContextDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_MessageContextDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_MessageContextDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_MessageContextDecodeErrorZ* operator ->() const { return &self; }
+};
 class CResult_InitFeaturesDecodeErrorZ {
 private:
 	LDKCResult_InitFeaturesDecodeErrorZ self;
@@ -8786,6 +10868,36 @@ public:
 	const LDKCResult_PingDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_PingDecodeErrorZ* operator ->() const { return &self; }
 };
+class CResult_RevocationKeyDecodeErrorZ {
+private:
+	LDKCResult_RevocationKeyDecodeErrorZ self;
+public:
+	CResult_RevocationKeyDecodeErrorZ(const CResult_RevocationKeyDecodeErrorZ&) = delete;
+	CResult_RevocationKeyDecodeErrorZ(CResult_RevocationKeyDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RevocationKeyDecodeErrorZ)); }
+	CResult_RevocationKeyDecodeErrorZ(LDKCResult_RevocationKeyDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RevocationKeyDecodeErrorZ)); }
+	operator LDKCResult_RevocationKeyDecodeErrorZ() && { LDKCResult_RevocationKeyDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RevocationKeyDecodeErrorZ)); return res; }
+	~CResult_RevocationKeyDecodeErrorZ() { CResult_RevocationKeyDecodeErrorZ_free(self); }
+	CResult_RevocationKeyDecodeErrorZ& operator=(CResult_RevocationKeyDecodeErrorZ&& o) { CResult_RevocationKeyDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RevocationKeyDecodeErrorZ)); return *this; }
+	LDKCResult_RevocationKeyDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_RevocationKeyDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_RevocationKeyDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_RevocationKeyDecodeErrorZ* operator ->() const { return &self; }
+};
+class C2Tuple_OffersMessageMessageSendInstructionsZ {
+private:
+	LDKC2Tuple_OffersMessageMessageSendInstructionsZ self;
+public:
+	C2Tuple_OffersMessageMessageSendInstructionsZ(const C2Tuple_OffersMessageMessageSendInstructionsZ&) = delete;
+	C2Tuple_OffersMessageMessageSendInstructionsZ(C2Tuple_OffersMessageMessageSendInstructionsZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_OffersMessageMessageSendInstructionsZ)); }
+	C2Tuple_OffersMessageMessageSendInstructionsZ(LDKC2Tuple_OffersMessageMessageSendInstructionsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_OffersMessageMessageSendInstructionsZ)); }
+	operator LDKC2Tuple_OffersMessageMessageSendInstructionsZ() && { LDKC2Tuple_OffersMessageMessageSendInstructionsZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_OffersMessageMessageSendInstructionsZ)); return res; }
+	~C2Tuple_OffersMessageMessageSendInstructionsZ() { C2Tuple_OffersMessageMessageSendInstructionsZ_free(self); }
+	C2Tuple_OffersMessageMessageSendInstructionsZ& operator=(C2Tuple_OffersMessageMessageSendInstructionsZ&& o) { C2Tuple_OffersMessageMessageSendInstructionsZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_OffersMessageMessageSendInstructionsZ)); return *this; }
+	LDKC2Tuple_OffersMessageMessageSendInstructionsZ* operator &() { return &self; }
+	LDKC2Tuple_OffersMessageMessageSendInstructionsZ* operator ->() { return &self; }
+	const LDKC2Tuple_OffersMessageMessageSendInstructionsZ* operator &() const { return &self; }
+	const LDKC2Tuple_OffersMessageMessageSendInstructionsZ* operator ->() const { return &self; }
+};
 class CResult_BlindedHopFeaturesDecodeErrorZ {
 private:
 	LDKCResult_BlindedHopFeaturesDecodeErrorZ self;
@@ -8801,6 +10913,21 @@ public:
 	const LDKCResult_BlindedHopFeaturesDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_BlindedHopFeaturesDecodeErrorZ* operator ->() const { return &self; }
 };
+class CResult_ChannelIdDecodeErrorZ {
+private:
+	LDKCResult_ChannelIdDecodeErrorZ self;
+public:
+	CResult_ChannelIdDecodeErrorZ(const CResult_ChannelIdDecodeErrorZ&) = delete;
+	CResult_ChannelIdDecodeErrorZ(CResult_ChannelIdDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelIdDecodeErrorZ)); }
+	CResult_ChannelIdDecodeErrorZ(LDKCResult_ChannelIdDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelIdDecodeErrorZ)); }
+	operator LDKCResult_ChannelIdDecodeErrorZ() && { LDKCResult_ChannelIdDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelIdDecodeErrorZ)); return res; }
+	~CResult_ChannelIdDecodeErrorZ() { CResult_ChannelIdDecodeErrorZ_free(self); }
+	CResult_ChannelIdDecodeErrorZ& operator=(CResult_ChannelIdDecodeErrorZ&& o) { CResult_ChannelIdDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelIdDecodeErrorZ)); return *this; }
+	LDKCResult_ChannelIdDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_ChannelIdDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_ChannelIdDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_ChannelIdDecodeErrorZ* operator ->() const { return &self; }
+};
 class CVec_TransactionOutputsZ {
 private:
 	LDKCVec_TransactionOutputsZ self;
@@ -8846,20 +10973,20 @@ public:
 	const LDKCOption_boolZ* operator &() const { return &self; }
 	const LDKCOption_boolZ* operator ->() const { return &self; }
 };
-class CVec_CVec_u8ZZ {
+class CVec_BlindedPaymentPathZ {
 private:
-	LDKCVec_CVec_u8ZZ self;
+	LDKCVec_BlindedPaymentPathZ self;
 public:
-	CVec_CVec_u8ZZ(const CVec_CVec_u8ZZ&) = delete;
-	CVec_CVec_u8ZZ(CVec_CVec_u8ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_CVec_u8ZZ)); }
-	CVec_CVec_u8ZZ(LDKCVec_CVec_u8ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_CVec_u8ZZ)); }
-	operator LDKCVec_CVec_u8ZZ() && { LDKCVec_CVec_u8ZZ res = self; memset(&self, 0, sizeof(LDKCVec_CVec_u8ZZ)); return res; }
-	~CVec_CVec_u8ZZ() { CVec_CVec_u8ZZ_free(self); }
-	CVec_CVec_u8ZZ& operator=(CVec_CVec_u8ZZ&& o) { CVec_CVec_u8ZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_CVec_u8ZZ)); return *this; }
-	LDKCVec_CVec_u8ZZ* operator &() { return &self; }
-	LDKCVec_CVec_u8ZZ* operator ->() { return &self; }
-	const LDKCVec_CVec_u8ZZ* operator &() const { return &self; }
-	const LDKCVec_CVec_u8ZZ* operator ->() const { return &self; }
+	CVec_BlindedPaymentPathZ(const CVec_BlindedPaymentPathZ&) = delete;
+	CVec_BlindedPaymentPathZ(CVec_BlindedPaymentPathZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_BlindedPaymentPathZ)); }
+	CVec_BlindedPaymentPathZ(LDKCVec_BlindedPaymentPathZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_BlindedPaymentPathZ)); }
+	operator LDKCVec_BlindedPaymentPathZ() && { LDKCVec_BlindedPaymentPathZ res = self; memset(&self, 0, sizeof(LDKCVec_BlindedPaymentPathZ)); return res; }
+	~CVec_BlindedPaymentPathZ() { CVec_BlindedPaymentPathZ_free(self); }
+	CVec_BlindedPaymentPathZ& operator=(CVec_BlindedPaymentPathZ&& o) { CVec_BlindedPaymentPathZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_BlindedPaymentPathZ)); return *this; }
+	LDKCVec_BlindedPaymentPathZ* operator &() { return &self; }
+	LDKCVec_BlindedPaymentPathZ* operator ->() { return &self; }
+	const LDKCVec_BlindedPaymentPathZ* operator &() const { return &self; }
+	const LDKCVec_BlindedPaymentPathZ* operator ->() const { return &self; }
 };
 class CResult_ProbabilisticScorerDecodeErrorZ {
 private:
@@ -8876,21 +11003,6 @@ public:
 	const LDKCResult_ProbabilisticScorerDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_ProbabilisticScorerDecodeErrorZ* operator ->() const { return &self; }
 };
-class CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ {
-private:
-	LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ self;
-public:
-	CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ(const CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ&) = delete;
-	CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ(CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ)); }
-	CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ(LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ)); }
-	operator LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ() && { LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ)); return res; }
-	~CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ() { CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ_free(self); }
-	CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ& operator=(CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ&& o) { CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ)); return *this; }
-	LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ* operator &() { return &self; }
-	LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ* operator ->() { return &self; }
-	const LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ* operator &() const { return &self; }
-	const LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ* operator ->() const { return &self; }
-};
 class COption_StrZ {
 private:
 	LDKCOption_StrZ self;
@@ -8906,20 +11018,35 @@ public:
 	const LDKCOption_StrZ* operator &() const { return &self; }
 	const LDKCOption_StrZ* operator ->() const { return &self; }
 };
-class CResult_ShutdownScriptDecodeErrorZ {
+class CResult_CVec_BlindedPaymentPathZNoneZ {
 private:
-	LDKCResult_ShutdownScriptDecodeErrorZ self;
+	LDKCResult_CVec_BlindedPaymentPathZNoneZ self;
 public:
-	CResult_ShutdownScriptDecodeErrorZ(const CResult_ShutdownScriptDecodeErrorZ&) = delete;
-	CResult_ShutdownScriptDecodeErrorZ(CResult_ShutdownScriptDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ShutdownScriptDecodeErrorZ)); }
-	CResult_ShutdownScriptDecodeErrorZ(LDKCResult_ShutdownScriptDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ShutdownScriptDecodeErrorZ)); }
-	operator LDKCResult_ShutdownScriptDecodeErrorZ() && { LDKCResult_ShutdownScriptDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ShutdownScriptDecodeErrorZ)); return res; }
-	~CResult_ShutdownScriptDecodeErrorZ() { CResult_ShutdownScriptDecodeErrorZ_free(self); }
-	CResult_ShutdownScriptDecodeErrorZ& operator=(CResult_ShutdownScriptDecodeErrorZ&& o) { CResult_ShutdownScriptDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ShutdownScriptDecodeErrorZ)); return *this; }
-	LDKCResult_ShutdownScriptDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_ShutdownScriptDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_ShutdownScriptDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_ShutdownScriptDecodeErrorZ* operator ->() const { return &self; }
+	CResult_CVec_BlindedPaymentPathZNoneZ(const CResult_CVec_BlindedPaymentPathZNoneZ&) = delete;
+	CResult_CVec_BlindedPaymentPathZNoneZ(CResult_CVec_BlindedPaymentPathZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_BlindedPaymentPathZNoneZ)); }
+	CResult_CVec_BlindedPaymentPathZNoneZ(LDKCResult_CVec_BlindedPaymentPathZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_BlindedPaymentPathZNoneZ)); }
+	operator LDKCResult_CVec_BlindedPaymentPathZNoneZ() && { LDKCResult_CVec_BlindedPaymentPathZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_BlindedPaymentPathZNoneZ)); return res; }
+	~CResult_CVec_BlindedPaymentPathZNoneZ() { CResult_CVec_BlindedPaymentPathZNoneZ_free(self); }
+	CResult_CVec_BlindedPaymentPathZNoneZ& operator=(CResult_CVec_BlindedPaymentPathZNoneZ&& o) { CResult_CVec_BlindedPaymentPathZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_BlindedPaymentPathZNoneZ)); return *this; }
+	LDKCResult_CVec_BlindedPaymentPathZNoneZ* operator &() { return &self; }
+	LDKCResult_CVec_BlindedPaymentPathZNoneZ* operator ->() { return &self; }
+	const LDKCResult_CVec_BlindedPaymentPathZNoneZ* operator &() const { return &self; }
+	const LDKCResult_CVec_BlindedPaymentPathZNoneZ* operator ->() const { return &self; }
+};
+class COption_C2Tuple_OffersMessageResponseInstructionZZ {
+private:
+	LDKCOption_C2Tuple_OffersMessageResponseInstructionZZ self;
+public:
+	COption_C2Tuple_OffersMessageResponseInstructionZZ(const COption_C2Tuple_OffersMessageResponseInstructionZZ&) = delete;
+	COption_C2Tuple_OffersMessageResponseInstructionZZ(COption_C2Tuple_OffersMessageResponseInstructionZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_C2Tuple_OffersMessageResponseInstructionZZ)); }
+	COption_C2Tuple_OffersMessageResponseInstructionZZ(LDKCOption_C2Tuple_OffersMessageResponseInstructionZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_C2Tuple_OffersMessageResponseInstructionZZ)); }
+	operator LDKCOption_C2Tuple_OffersMessageResponseInstructionZZ() && { LDKCOption_C2Tuple_OffersMessageResponseInstructionZZ res = self; memset(&self, 0, sizeof(LDKCOption_C2Tuple_OffersMessageResponseInstructionZZ)); return res; }
+	~COption_C2Tuple_OffersMessageResponseInstructionZZ() { COption_C2Tuple_OffersMessageResponseInstructionZZ_free(self); }
+	COption_C2Tuple_OffersMessageResponseInstructionZZ& operator=(COption_C2Tuple_OffersMessageResponseInstructionZZ&& o) { COption_C2Tuple_OffersMessageResponseInstructionZZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_C2Tuple_OffersMessageResponseInstructionZZ)); return *this; }
+	LDKCOption_C2Tuple_OffersMessageResponseInstructionZZ* operator &() { return &self; }
+	LDKCOption_C2Tuple_OffersMessageResponseInstructionZZ* operator ->() { return &self; }
+	const LDKCOption_C2Tuple_OffersMessageResponseInstructionZZ* operator &() const { return &self; }
+	const LDKCOption_C2Tuple_OffersMessageResponseInstructionZZ* operator ->() const { return &self; }
 };
 class C2Tuple_usizeTransactionZ {
 private:
@@ -8936,6 +11063,21 @@ public:
 	const LDKC2Tuple_usizeTransactionZ* operator &() const { return &self; }
 	const LDKC2Tuple_usizeTransactionZ* operator ->() const { return &self; }
 };
+class COption_OffersContextZ {
+private:
+	LDKCOption_OffersContextZ self;
+public:
+	COption_OffersContextZ(const COption_OffersContextZ&) = delete;
+	COption_OffersContextZ(COption_OffersContextZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_OffersContextZ)); }
+	COption_OffersContextZ(LDKCOption_OffersContextZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_OffersContextZ)); }
+	operator LDKCOption_OffersContextZ() && { LDKCOption_OffersContextZ res = self; memset(&self, 0, sizeof(LDKCOption_OffersContextZ)); return res; }
+	~COption_OffersContextZ() { COption_OffersContextZ_free(self); }
+	COption_OffersContextZ& operator=(COption_OffersContextZ&& o) { COption_OffersContextZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_OffersContextZ)); return *this; }
+	LDKCOption_OffersContextZ* operator &() { return &self; }
+	LDKCOption_OffersContextZ* operator ->() { return &self; }
+	const LDKCOption_OffersContextZ* operator &() const { return &self; }
+	const LDKCOption_OffersContextZ* operator ->() const { return &self; }
+};
 class CResult_NodeAnnouncementDecodeErrorZ {
 private:
 	LDKCResult_NodeAnnouncementDecodeErrorZ self;
@@ -8951,21 +11093,6 @@ public:
 	const LDKCResult_NodeAnnouncementDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_NodeAnnouncementDecodeErrorZ* operator ->() const { return &self; }
 };
-class CVec_FutureZ {
-private:
-	LDKCVec_FutureZ self;
-public:
-	CVec_FutureZ(const CVec_FutureZ&) = delete;
-	CVec_FutureZ(CVec_FutureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_FutureZ)); }
-	CVec_FutureZ(LDKCVec_FutureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_FutureZ)); }
-	operator LDKCVec_FutureZ() && { LDKCVec_FutureZ res = self; memset(&self, 0, sizeof(LDKCVec_FutureZ)); return res; }
-	~CVec_FutureZ() { CVec_FutureZ_free(self); }
-	CVec_FutureZ& operator=(CVec_FutureZ&& o) { CVec_FutureZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_FutureZ)); return *this; }
-	LDKCVec_FutureZ* operator &() { return &self; }
-	LDKCVec_FutureZ* operator ->() { return &self; }
-	const LDKCVec_FutureZ* operator &() const { return &self; }
-	const LDKCVec_FutureZ* operator ->() const { return &self; }
-};
 class CVec_ChannelMonitorZ {
 private:
 	LDKCVec_ChannelMonitorZ self;
@@ -8996,20 +11123,20 @@ public:
 	const LDKCResult_AcceptChannelV2DecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_AcceptChannelV2DecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_TxCreationKeysDecodeErrorZ {
+class CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ {
 private:
-	LDKCResult_TxCreationKeysDecodeErrorZ self;
+	LDKCResult_COption_InboundHTLCStateDetailsZDecodeErrorZ self;
 public:
-	CResult_TxCreationKeysDecodeErrorZ(const CResult_TxCreationKeysDecodeErrorZ&) = delete;
-	CResult_TxCreationKeysDecodeErrorZ(CResult_TxCreationKeysDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxCreationKeysDecodeErrorZ)); }
-	CResult_TxCreationKeysDecodeErrorZ(LDKCResult_TxCreationKeysDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxCreationKeysDecodeErrorZ)); }
-	operator LDKCResult_TxCreationKeysDecodeErrorZ() && { LDKCResult_TxCreationKeysDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxCreationKeysDecodeErrorZ)); return res; }
-	~CResult_TxCreationKeysDecodeErrorZ() { CResult_TxCreationKeysDecodeErrorZ_free(self); }
-	CResult_TxCreationKeysDecodeErrorZ& operator=(CResult_TxCreationKeysDecodeErrorZ&& o) { CResult_TxCreationKeysDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxCreationKeysDecodeErrorZ)); return *this; }
-	LDKCResult_TxCreationKeysDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_TxCreationKeysDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_TxCreationKeysDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_TxCreationKeysDecodeErrorZ* operator ->() const { return &self; }
+	CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ(const CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ&) = delete;
+	CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ(CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ)); }
+	CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ(LDKCResult_COption_InboundHTLCStateDetailsZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_InboundHTLCStateDetailsZDecodeErrorZ)); }
+	operator LDKCResult_COption_InboundHTLCStateDetailsZDecodeErrorZ() && { LDKCResult_COption_InboundHTLCStateDetailsZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_InboundHTLCStateDetailsZDecodeErrorZ)); return res; }
+	~CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ() { CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ_free(self); }
+	CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ& operator=(CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ&& o) { CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ)); return *this; }
+	LDKCResult_COption_InboundHTLCStateDetailsZDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_COption_InboundHTLCStateDetailsZDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_COption_InboundHTLCStateDetailsZDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_COption_InboundHTLCStateDetailsZDecodeErrorZ* operator ->() const { return &self; }
 };
 class CResult_RouteHopDecodeErrorZ {
 private:
@@ -9026,6 +11153,21 @@ public:
 	const LDKCResult_RouteHopDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_RouteHopDecodeErrorZ* operator ->() const { return &self; }
 };
+class CResult_OfferIdDecodeErrorZ {
+private:
+	LDKCResult_OfferIdDecodeErrorZ self;
+public:
+	CResult_OfferIdDecodeErrorZ(const CResult_OfferIdDecodeErrorZ&) = delete;
+	CResult_OfferIdDecodeErrorZ(CResult_OfferIdDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OfferIdDecodeErrorZ)); }
+	CResult_OfferIdDecodeErrorZ(LDKCResult_OfferIdDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OfferIdDecodeErrorZ)); }
+	operator LDKCResult_OfferIdDecodeErrorZ() && { LDKCResult_OfferIdDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OfferIdDecodeErrorZ)); return res; }
+	~CResult_OfferIdDecodeErrorZ() { CResult_OfferIdDecodeErrorZ_free(self); }
+	CResult_OfferIdDecodeErrorZ& operator=(CResult_OfferIdDecodeErrorZ&& o) { CResult_OfferIdDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OfferIdDecodeErrorZ)); return *this; }
+	LDKCResult_OfferIdDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_OfferIdDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_OfferIdDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_OfferIdDecodeErrorZ* operator ->() const { return &self; }
+};
 class CVec_HTLCOutputInCommitmentZ {
 private:
 	LDKCVec_HTLCOutputInCommitmentZ self;
@@ -9056,65 +11198,50 @@ public:
 	const LDKCResult_CoinSelectionNoneZ* operator &() const { return &self; }
 	const LDKCResult_CoinSelectionNoneZ* operator ->() const { return &self; }
 };
-class C2Tuple_ThirtyTwoBytesPublicKeyZ {
-private:
-	LDKC2Tuple_ThirtyTwoBytesPublicKeyZ self;
-public:
-	C2Tuple_ThirtyTwoBytesPublicKeyZ(const C2Tuple_ThirtyTwoBytesPublicKeyZ&) = delete;
-	C2Tuple_ThirtyTwoBytesPublicKeyZ(C2Tuple_ThirtyTwoBytesPublicKeyZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesPublicKeyZ)); }
-	C2Tuple_ThirtyTwoBytesPublicKeyZ(LDKC2Tuple_ThirtyTwoBytesPublicKeyZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesPublicKeyZ)); }
-	operator LDKC2Tuple_ThirtyTwoBytesPublicKeyZ() && { LDKC2Tuple_ThirtyTwoBytesPublicKeyZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesPublicKeyZ)); return res; }
-	~C2Tuple_ThirtyTwoBytesPublicKeyZ() { C2Tuple_ThirtyTwoBytesPublicKeyZ_free(self); }
-	C2Tuple_ThirtyTwoBytesPublicKeyZ& operator=(C2Tuple_ThirtyTwoBytesPublicKeyZ&& o) { C2Tuple_ThirtyTwoBytesPublicKeyZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesPublicKeyZ)); return *this; }
-	LDKC2Tuple_ThirtyTwoBytesPublicKeyZ* operator &() { return &self; }
-	LDKC2Tuple_ThirtyTwoBytesPublicKeyZ* operator ->() { return &self; }
-	const LDKC2Tuple_ThirtyTwoBytesPublicKeyZ* operator &() const { return &self; }
-	const LDKC2Tuple_ThirtyTwoBytesPublicKeyZ* operator ->() const { return &self; }
-};
-class CResult_SiPrefixBolt11ParseErrorZ {
+class CVec_FutureZ {
 private:
-	LDKCResult_SiPrefixBolt11ParseErrorZ self;
+	LDKCVec_FutureZ self;
 public:
-	CResult_SiPrefixBolt11ParseErrorZ(const CResult_SiPrefixBolt11ParseErrorZ&) = delete;
-	CResult_SiPrefixBolt11ParseErrorZ(CResult_SiPrefixBolt11ParseErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SiPrefixBolt11ParseErrorZ)); }
-	CResult_SiPrefixBolt11ParseErrorZ(LDKCResult_SiPrefixBolt11ParseErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SiPrefixBolt11ParseErrorZ)); }
-	operator LDKCResult_SiPrefixBolt11ParseErrorZ() && { LDKCResult_SiPrefixBolt11ParseErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SiPrefixBolt11ParseErrorZ)); return res; }
-	~CResult_SiPrefixBolt11ParseErrorZ() { CResult_SiPrefixBolt11ParseErrorZ_free(self); }
-	CResult_SiPrefixBolt11ParseErrorZ& operator=(CResult_SiPrefixBolt11ParseErrorZ&& o) { CResult_SiPrefixBolt11ParseErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SiPrefixBolt11ParseErrorZ)); return *this; }
-	LDKCResult_SiPrefixBolt11ParseErrorZ* operator &() { return &self; }
-	LDKCResult_SiPrefixBolt11ParseErrorZ* operator ->() { return &self; }
-	const LDKCResult_SiPrefixBolt11ParseErrorZ* operator &() const { return &self; }
-	const LDKCResult_SiPrefixBolt11ParseErrorZ* operator ->() const { return &self; }
+	CVec_FutureZ(const CVec_FutureZ&) = delete;
+	CVec_FutureZ(CVec_FutureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_FutureZ)); }
+	CVec_FutureZ(LDKCVec_FutureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_FutureZ)); }
+	operator LDKCVec_FutureZ() && { LDKCVec_FutureZ res = self; memset(&self, 0, sizeof(LDKCVec_FutureZ)); return res; }
+	~CVec_FutureZ() { CVec_FutureZ_free(self); }
+	CVec_FutureZ& operator=(CVec_FutureZ&& o) { CVec_FutureZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_FutureZ)); return *this; }
+	LDKCVec_FutureZ* operator &() { return &self; }
+	LDKCVec_FutureZ* operator ->() { return &self; }
+	const LDKCVec_FutureZ* operator &() const { return &self; }
+	const LDKCVec_FutureZ* operator ->() const { return &self; }
 };
-class CResult_BlindedPathDecodeErrorZ {
+class CResult_TxCreationKeysDecodeErrorZ {
 private:
-	LDKCResult_BlindedPathDecodeErrorZ self;
+	LDKCResult_TxCreationKeysDecodeErrorZ self;
 public:
-	CResult_BlindedPathDecodeErrorZ(const CResult_BlindedPathDecodeErrorZ&) = delete;
-	CResult_BlindedPathDecodeErrorZ(CResult_BlindedPathDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedPathDecodeErrorZ)); }
-	CResult_BlindedPathDecodeErrorZ(LDKCResult_BlindedPathDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedPathDecodeErrorZ)); }
-	operator LDKCResult_BlindedPathDecodeErrorZ() && { LDKCResult_BlindedPathDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedPathDecodeErrorZ)); return res; }
-	~CResult_BlindedPathDecodeErrorZ() { CResult_BlindedPathDecodeErrorZ_free(self); }
-	CResult_BlindedPathDecodeErrorZ& operator=(CResult_BlindedPathDecodeErrorZ&& o) { CResult_BlindedPathDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedPathDecodeErrorZ)); return *this; }
-	LDKCResult_BlindedPathDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_BlindedPathDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_BlindedPathDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_BlindedPathDecodeErrorZ* operator ->() const { return &self; }
+	CResult_TxCreationKeysDecodeErrorZ(const CResult_TxCreationKeysDecodeErrorZ&) = delete;
+	CResult_TxCreationKeysDecodeErrorZ(CResult_TxCreationKeysDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxCreationKeysDecodeErrorZ)); }
+	CResult_TxCreationKeysDecodeErrorZ(LDKCResult_TxCreationKeysDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxCreationKeysDecodeErrorZ)); }
+	operator LDKCResult_TxCreationKeysDecodeErrorZ() && { LDKCResult_TxCreationKeysDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxCreationKeysDecodeErrorZ)); return res; }
+	~CResult_TxCreationKeysDecodeErrorZ() { CResult_TxCreationKeysDecodeErrorZ_free(self); }
+	CResult_TxCreationKeysDecodeErrorZ& operator=(CResult_TxCreationKeysDecodeErrorZ&& o) { CResult_TxCreationKeysDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxCreationKeysDecodeErrorZ)); return *this; }
+	LDKCResult_TxCreationKeysDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_TxCreationKeysDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_TxCreationKeysDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_TxCreationKeysDecodeErrorZ* operator ->() const { return &self; }
 };
-class CVec_BalanceZ {
+class CResult_RefundBolt12SemanticErrorZ {
 private:
-	LDKCVec_BalanceZ self;
+	LDKCResult_RefundBolt12SemanticErrorZ self;
 public:
-	CVec_BalanceZ(const CVec_BalanceZ&) = delete;
-	CVec_BalanceZ(CVec_BalanceZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_BalanceZ)); }
-	CVec_BalanceZ(LDKCVec_BalanceZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_BalanceZ)); }
-	operator LDKCVec_BalanceZ() && { LDKCVec_BalanceZ res = self; memset(&self, 0, sizeof(LDKCVec_BalanceZ)); return res; }
-	~CVec_BalanceZ() { CVec_BalanceZ_free(self); }
-	CVec_BalanceZ& operator=(CVec_BalanceZ&& o) { CVec_BalanceZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_BalanceZ)); return *this; }
-	LDKCVec_BalanceZ* operator &() { return &self; }
-	LDKCVec_BalanceZ* operator ->() { return &self; }
-	const LDKCVec_BalanceZ* operator &() const { return &self; }
-	const LDKCVec_BalanceZ* operator ->() const { return &self; }
+	CResult_RefundBolt12SemanticErrorZ(const CResult_RefundBolt12SemanticErrorZ&) = delete;
+	CResult_RefundBolt12SemanticErrorZ(CResult_RefundBolt12SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RefundBolt12SemanticErrorZ)); }
+	CResult_RefundBolt12SemanticErrorZ(LDKCResult_RefundBolt12SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RefundBolt12SemanticErrorZ)); }
+	operator LDKCResult_RefundBolt12SemanticErrorZ() && { LDKCResult_RefundBolt12SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RefundBolt12SemanticErrorZ)); return res; }
+	~CResult_RefundBolt12SemanticErrorZ() { CResult_RefundBolt12SemanticErrorZ_free(self); }
+	CResult_RefundBolt12SemanticErrorZ& operator=(CResult_RefundBolt12SemanticErrorZ&& o) { CResult_RefundBolt12SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RefundBolt12SemanticErrorZ)); return *this; }
+	LDKCResult_RefundBolt12SemanticErrorZ* operator &() { return &self; }
+	LDKCResult_RefundBolt12SemanticErrorZ* operator ->() { return &self; }
+	const LDKCResult_RefundBolt12SemanticErrorZ* operator &() const { return &self; }
+	const LDKCResult_RefundBolt12SemanticErrorZ* operator ->() const { return &self; }
 };
 class CResult_NoneIOErrorZ {
 private:
@@ -9146,6 +11273,21 @@ public:
 	const LDKCResult_MaxDustHTLCExposureDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_MaxDustHTLCExposureDecodeErrorZ* operator ->() const { return &self; }
 };
+class CVec_BalanceZ {
+private:
+	LDKCVec_BalanceZ self;
+public:
+	CVec_BalanceZ(const CVec_BalanceZ&) = delete;
+	CVec_BalanceZ(CVec_BalanceZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_BalanceZ)); }
+	CVec_BalanceZ(LDKCVec_BalanceZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_BalanceZ)); }
+	operator LDKCVec_BalanceZ() && { LDKCVec_BalanceZ res = self; memset(&self, 0, sizeof(LDKCVec_BalanceZ)); return res; }
+	~CVec_BalanceZ() { CVec_BalanceZ_free(self); }
+	CVec_BalanceZ& operator=(CVec_BalanceZ&& o) { CVec_BalanceZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_BalanceZ)); return *this; }
+	LDKCVec_BalanceZ* operator &() { return &self; }
+	LDKCVec_BalanceZ* operator ->() { return &self; }
+	const LDKCVec_BalanceZ* operator &() const { return &self; }
+	const LDKCVec_BalanceZ* operator ->() const { return &self; }
+};
 class CVec_CommitmentTransactionZ {
 private:
 	LDKCVec_CommitmentTransactionZ self;
@@ -9221,6 +11363,51 @@ public:
 	const LDKC2Tuple_Z* operator &() const { return &self; }
 	const LDKC2Tuple_Z* operator ->() const { return &self; }
 };
+class CResult_ShutdownScriptDecodeErrorZ {
+private:
+	LDKCResult_ShutdownScriptDecodeErrorZ self;
+public:
+	CResult_ShutdownScriptDecodeErrorZ(const CResult_ShutdownScriptDecodeErrorZ&) = delete;
+	CResult_ShutdownScriptDecodeErrorZ(CResult_ShutdownScriptDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ShutdownScriptDecodeErrorZ)); }
+	CResult_ShutdownScriptDecodeErrorZ(LDKCResult_ShutdownScriptDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ShutdownScriptDecodeErrorZ)); }
+	operator LDKCResult_ShutdownScriptDecodeErrorZ() && { LDKCResult_ShutdownScriptDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ShutdownScriptDecodeErrorZ)); return res; }
+	~CResult_ShutdownScriptDecodeErrorZ() { CResult_ShutdownScriptDecodeErrorZ_free(self); }
+	CResult_ShutdownScriptDecodeErrorZ& operator=(CResult_ShutdownScriptDecodeErrorZ&& o) { CResult_ShutdownScriptDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ShutdownScriptDecodeErrorZ)); return *this; }
+	LDKCResult_ShutdownScriptDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_ShutdownScriptDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_ShutdownScriptDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_ShutdownScriptDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_InboundHTLCDetailsDecodeErrorZ {
+private:
+	LDKCResult_InboundHTLCDetailsDecodeErrorZ self;
+public:
+	CResult_InboundHTLCDetailsDecodeErrorZ(const CResult_InboundHTLCDetailsDecodeErrorZ&) = delete;
+	CResult_InboundHTLCDetailsDecodeErrorZ(CResult_InboundHTLCDetailsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InboundHTLCDetailsDecodeErrorZ)); }
+	CResult_InboundHTLCDetailsDecodeErrorZ(LDKCResult_InboundHTLCDetailsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InboundHTLCDetailsDecodeErrorZ)); }
+	operator LDKCResult_InboundHTLCDetailsDecodeErrorZ() && { LDKCResult_InboundHTLCDetailsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InboundHTLCDetailsDecodeErrorZ)); return res; }
+	~CResult_InboundHTLCDetailsDecodeErrorZ() { CResult_InboundHTLCDetailsDecodeErrorZ_free(self); }
+	CResult_InboundHTLCDetailsDecodeErrorZ& operator=(CResult_InboundHTLCDetailsDecodeErrorZ&& o) { CResult_InboundHTLCDetailsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InboundHTLCDetailsDecodeErrorZ)); return *this; }
+	LDKCResult_InboundHTLCDetailsDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_InboundHTLCDetailsDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_InboundHTLCDetailsDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_InboundHTLCDetailsDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_SiPrefixBolt11ParseErrorZ {
+private:
+	LDKCResult_SiPrefixBolt11ParseErrorZ self;
+public:
+	CResult_SiPrefixBolt11ParseErrorZ(const CResult_SiPrefixBolt11ParseErrorZ&) = delete;
+	CResult_SiPrefixBolt11ParseErrorZ(CResult_SiPrefixBolt11ParseErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SiPrefixBolt11ParseErrorZ)); }
+	CResult_SiPrefixBolt11ParseErrorZ(LDKCResult_SiPrefixBolt11ParseErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SiPrefixBolt11ParseErrorZ)); }
+	operator LDKCResult_SiPrefixBolt11ParseErrorZ() && { LDKCResult_SiPrefixBolt11ParseErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SiPrefixBolt11ParseErrorZ)); return res; }
+	~CResult_SiPrefixBolt11ParseErrorZ() { CResult_SiPrefixBolt11ParseErrorZ_free(self); }
+	CResult_SiPrefixBolt11ParseErrorZ& operator=(CResult_SiPrefixBolt11ParseErrorZ&& o) { CResult_SiPrefixBolt11ParseErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SiPrefixBolt11ParseErrorZ)); return *this; }
+	LDKCResult_SiPrefixBolt11ParseErrorZ* operator &() { return &self; }
+	LDKCResult_SiPrefixBolt11ParseErrorZ* operator ->() { return &self; }
+	const LDKCResult_SiPrefixBolt11ParseErrorZ* operator &() const { return &self; }
+	const LDKCResult_SiPrefixBolt11ParseErrorZ* operator ->() const { return &self; }
+};
 class C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ {
 private:
 	LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ self;
@@ -9416,6 +11603,21 @@ public:
 	const LDKCVec_SocketAddressZ* operator &() const { return &self; }
 	const LDKCVec_SocketAddressZ* operator ->() const { return &self; }
 };
+class CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ {
+private:
+	LDKCVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ self;
+public:
+	CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ(const CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ&) = delete;
+	CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ(CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ)); }
+	CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ(LDKCVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ)); }
+	operator LDKCVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ() && { LDKCVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ res = self; memset(&self, 0, sizeof(LDKCVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ)); return res; }
+	~CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ() { CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ_free(self); }
+	CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ& operator=(CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ&& o) { CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ)); return *this; }
+	LDKCVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ* operator &() { return &self; }
+	LDKCVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ* operator ->() { return &self; }
+	const LDKCVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ* operator &() const { return &self; }
+	const LDKCVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ* operator ->() const { return &self; }
+};
 class CResult_ThirtyTwoBytesPaymentSendFailureZ {
 private:
 	LDKCResult_ThirtyTwoBytesPaymentSendFailureZ self;
@@ -9431,21 +11633,6 @@ public:
 	const LDKCResult_ThirtyTwoBytesPaymentSendFailureZ* operator &() const { return &self; }
 	const LDKCResult_ThirtyTwoBytesPaymentSendFailureZ* operator ->() const { return &self; }
 };
-class CResult_HolderCommitmentTransactionDecodeErrorZ {
-private:
-	LDKCResult_HolderCommitmentTransactionDecodeErrorZ self;
-public:
-	CResult_HolderCommitmentTransactionDecodeErrorZ(const CResult_HolderCommitmentTransactionDecodeErrorZ&) = delete;
-	CResult_HolderCommitmentTransactionDecodeErrorZ(CResult_HolderCommitmentTransactionDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HolderCommitmentTransactionDecodeErrorZ)); }
-	CResult_HolderCommitmentTransactionDecodeErrorZ(LDKCResult_HolderCommitmentTransactionDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ)); }
-	operator LDKCResult_HolderCommitmentTransactionDecodeErrorZ() && { LDKCResult_HolderCommitmentTransactionDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ)); return res; }
-	~CResult_HolderCommitmentTransactionDecodeErrorZ() { CResult_HolderCommitmentTransactionDecodeErrorZ_free(self); }
-	CResult_HolderCommitmentTransactionDecodeErrorZ& operator=(CResult_HolderCommitmentTransactionDecodeErrorZ&& o) { CResult_HolderCommitmentTransactionDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HolderCommitmentTransactionDecodeErrorZ)); return *this; }
-	LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator ->() const { return &self; }
-};
 class CResult_WarningMessageDecodeErrorZ {
 private:
 	LDKCResult_WarningMessageDecodeErrorZ self;
@@ -9476,20 +11663,65 @@ public:
 	const LDKCResult_ChannelCounterpartyDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_ChannelCounterpartyDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_InitDecodeErrorZ {
+class CResult_HolderCommitmentTransactionDecodeErrorZ {
 private:
-	LDKCResult_InitDecodeErrorZ self;
+	LDKCResult_HolderCommitmentTransactionDecodeErrorZ self;
 public:
-	CResult_InitDecodeErrorZ(const CResult_InitDecodeErrorZ&) = delete;
-	CResult_InitDecodeErrorZ(CResult_InitDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InitDecodeErrorZ)); }
-	CResult_InitDecodeErrorZ(LDKCResult_InitDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InitDecodeErrorZ)); }
-	operator LDKCResult_InitDecodeErrorZ() && { LDKCResult_InitDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InitDecodeErrorZ)); return res; }
-	~CResult_InitDecodeErrorZ() { CResult_InitDecodeErrorZ_free(self); }
-	CResult_InitDecodeErrorZ& operator=(CResult_InitDecodeErrorZ&& o) { CResult_InitDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InitDecodeErrorZ)); return *this; }
-	LDKCResult_InitDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_InitDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_InitDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_InitDecodeErrorZ* operator ->() const { return &self; }
+	CResult_HolderCommitmentTransactionDecodeErrorZ(const CResult_HolderCommitmentTransactionDecodeErrorZ&) = delete;
+	CResult_HolderCommitmentTransactionDecodeErrorZ(CResult_HolderCommitmentTransactionDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HolderCommitmentTransactionDecodeErrorZ)); }
+	CResult_HolderCommitmentTransactionDecodeErrorZ(LDKCResult_HolderCommitmentTransactionDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ)); }
+	operator LDKCResult_HolderCommitmentTransactionDecodeErrorZ() && { LDKCResult_HolderCommitmentTransactionDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ)); return res; }
+	~CResult_HolderCommitmentTransactionDecodeErrorZ() { CResult_HolderCommitmentTransactionDecodeErrorZ_free(self); }
+	CResult_HolderCommitmentTransactionDecodeErrorZ& operator=(CResult_HolderCommitmentTransactionDecodeErrorZ&& o) { CResult_HolderCommitmentTransactionDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HolderCommitmentTransactionDecodeErrorZ)); return *this; }
+	LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_DelayedPaymentKeyDecodeErrorZ {
+private:
+	LDKCResult_DelayedPaymentKeyDecodeErrorZ self;
+public:
+	CResult_DelayedPaymentKeyDecodeErrorZ(const CResult_DelayedPaymentKeyDecodeErrorZ&) = delete;
+	CResult_DelayedPaymentKeyDecodeErrorZ(CResult_DelayedPaymentKeyDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_DelayedPaymentKeyDecodeErrorZ)); }
+	CResult_DelayedPaymentKeyDecodeErrorZ(LDKCResult_DelayedPaymentKeyDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_DelayedPaymentKeyDecodeErrorZ)); }
+	operator LDKCResult_DelayedPaymentKeyDecodeErrorZ() && { LDKCResult_DelayedPaymentKeyDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_DelayedPaymentKeyDecodeErrorZ)); return res; }
+	~CResult_DelayedPaymentKeyDecodeErrorZ() { CResult_DelayedPaymentKeyDecodeErrorZ_free(self); }
+	CResult_DelayedPaymentKeyDecodeErrorZ& operator=(CResult_DelayedPaymentKeyDecodeErrorZ&& o) { CResult_DelayedPaymentKeyDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_DelayedPaymentKeyDecodeErrorZ)); return *this; }
+	LDKCResult_DelayedPaymentKeyDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_DelayedPaymentKeyDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_DelayedPaymentKeyDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_DelayedPaymentKeyDecodeErrorZ* operator ->() const { return &self; }
+};
+class C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ {
+private:
+	LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ self;
+public:
+	C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ(const C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ&) = delete;
+	C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ(C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ)); }
+	C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ(LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ)); }
+	operator LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ() && { LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ)); return res; }
+	~C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ() { C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_free(self); }
+	C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ& operator=(C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ&& o) { C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_free(self); self = o.self; memset(&o, 0, sizeof(C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ)); return *this; }
+	LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ* operator &() { return &self; }
+	LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ* operator ->() { return &self; }
+	const LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ* operator &() const { return &self; }
+	const LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ* operator ->() const { return &self; }
+};
+class CResult_OfferBolt12SemanticErrorZ {
+private:
+	LDKCResult_OfferBolt12SemanticErrorZ self;
+public:
+	CResult_OfferBolt12SemanticErrorZ(const CResult_OfferBolt12SemanticErrorZ&) = delete;
+	CResult_OfferBolt12SemanticErrorZ(CResult_OfferBolt12SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OfferBolt12SemanticErrorZ)); }
+	CResult_OfferBolt12SemanticErrorZ(LDKCResult_OfferBolt12SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OfferBolt12SemanticErrorZ)); }
+	operator LDKCResult_OfferBolt12SemanticErrorZ() && { LDKCResult_OfferBolt12SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OfferBolt12SemanticErrorZ)); return res; }
+	~CResult_OfferBolt12SemanticErrorZ() { CResult_OfferBolt12SemanticErrorZ_free(self); }
+	CResult_OfferBolt12SemanticErrorZ& operator=(CResult_OfferBolt12SemanticErrorZ&& o) { CResult_OfferBolt12SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OfferBolt12SemanticErrorZ)); return *this; }
+	LDKCResult_OfferBolt12SemanticErrorZ* operator &() { return &self; }
+	LDKCResult_OfferBolt12SemanticErrorZ* operator ->() { return &self; }
+	const LDKCResult_OfferBolt12SemanticErrorZ* operator &() const { return &self; }
+	const LDKCResult_OfferBolt12SemanticErrorZ* operator ->() const { return &self; }
 };
 class CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ {
 private:
@@ -9506,20 +11738,20 @@ public:
 	const LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_ClaimedHTLCDecodeErrorZ {
+class CResult_InitDecodeErrorZ {
 private:
-	LDKCResult_ClaimedHTLCDecodeErrorZ self;
+	LDKCResult_InitDecodeErrorZ self;
 public:
-	CResult_ClaimedHTLCDecodeErrorZ(const CResult_ClaimedHTLCDecodeErrorZ&) = delete;
-	CResult_ClaimedHTLCDecodeErrorZ(CResult_ClaimedHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ClaimedHTLCDecodeErrorZ)); }
-	CResult_ClaimedHTLCDecodeErrorZ(LDKCResult_ClaimedHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ClaimedHTLCDecodeErrorZ)); }
-	operator LDKCResult_ClaimedHTLCDecodeErrorZ() && { LDKCResult_ClaimedHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ClaimedHTLCDecodeErrorZ)); return res; }
-	~CResult_ClaimedHTLCDecodeErrorZ() { CResult_ClaimedHTLCDecodeErrorZ_free(self); }
-	CResult_ClaimedHTLCDecodeErrorZ& operator=(CResult_ClaimedHTLCDecodeErrorZ&& o) { CResult_ClaimedHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ClaimedHTLCDecodeErrorZ)); return *this; }
-	LDKCResult_ClaimedHTLCDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_ClaimedHTLCDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_ClaimedHTLCDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_ClaimedHTLCDecodeErrorZ* operator ->() const { return &self; }
+	CResult_InitDecodeErrorZ(const CResult_InitDecodeErrorZ&) = delete;
+	CResult_InitDecodeErrorZ(CResult_InitDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InitDecodeErrorZ)); }
+	CResult_InitDecodeErrorZ(LDKCResult_InitDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InitDecodeErrorZ)); }
+	operator LDKCResult_InitDecodeErrorZ() && { LDKCResult_InitDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InitDecodeErrorZ)); return res; }
+	~CResult_InitDecodeErrorZ() { CResult_InitDecodeErrorZ_free(self); }
+	CResult_InitDecodeErrorZ& operator=(CResult_InitDecodeErrorZ&& o) { CResult_InitDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InitDecodeErrorZ)); return *this; }
+	LDKCResult_InitDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_InitDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_InitDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_InitDecodeErrorZ* operator ->() const { return &self; }
 };
 class CResult_PaymentPurposeDecodeErrorZ {
 private:
@@ -9536,20 +11768,20 @@ public:
 	const LDKCResult_PaymentPurposeDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_PaymentPurposeDecodeErrorZ* operator ->() const { return &self; }
 };
-class CVec_MonitorUpdateIdZ {
+class CResult_ClaimedHTLCDecodeErrorZ {
 private:
-	LDKCVec_MonitorUpdateIdZ self;
+	LDKCResult_ClaimedHTLCDecodeErrorZ self;
 public:
-	CVec_MonitorUpdateIdZ(const CVec_MonitorUpdateIdZ&) = delete;
-	CVec_MonitorUpdateIdZ(CVec_MonitorUpdateIdZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_MonitorUpdateIdZ)); }
-	CVec_MonitorUpdateIdZ(LDKCVec_MonitorUpdateIdZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_MonitorUpdateIdZ)); }
-	operator LDKCVec_MonitorUpdateIdZ() && { LDKCVec_MonitorUpdateIdZ res = self; memset(&self, 0, sizeof(LDKCVec_MonitorUpdateIdZ)); return res; }
-	~CVec_MonitorUpdateIdZ() { CVec_MonitorUpdateIdZ_free(self); }
-	CVec_MonitorUpdateIdZ& operator=(CVec_MonitorUpdateIdZ&& o) { CVec_MonitorUpdateIdZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_MonitorUpdateIdZ)); return *this; }
-	LDKCVec_MonitorUpdateIdZ* operator &() { return &self; }
-	LDKCVec_MonitorUpdateIdZ* operator ->() { return &self; }
-	const LDKCVec_MonitorUpdateIdZ* operator &() const { return &self; }
-	const LDKCVec_MonitorUpdateIdZ* operator ->() const { return &self; }
+	CResult_ClaimedHTLCDecodeErrorZ(const CResult_ClaimedHTLCDecodeErrorZ&) = delete;
+	CResult_ClaimedHTLCDecodeErrorZ(CResult_ClaimedHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ClaimedHTLCDecodeErrorZ)); }
+	CResult_ClaimedHTLCDecodeErrorZ(LDKCResult_ClaimedHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ClaimedHTLCDecodeErrorZ)); }
+	operator LDKCResult_ClaimedHTLCDecodeErrorZ() && { LDKCResult_ClaimedHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ClaimedHTLCDecodeErrorZ)); return res; }
+	~CResult_ClaimedHTLCDecodeErrorZ() { CResult_ClaimedHTLCDecodeErrorZ_free(self); }
+	CResult_ClaimedHTLCDecodeErrorZ& operator=(CResult_ClaimedHTLCDecodeErrorZ&& o) { CResult_ClaimedHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ClaimedHTLCDecodeErrorZ)); return *this; }
+	LDKCResult_ClaimedHTLCDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_ClaimedHTLCDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_ClaimedHTLCDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_ClaimedHTLCDecodeErrorZ* operator ->() const { return &self; }
 };
 class CResult_OutPointDecodeErrorZ {
 private:
@@ -9611,6 +11843,21 @@ public:
 	const LDKCVec_MessageSendEventZ* operator &() const { return &self; }
 	const LDKCVec_MessageSendEventZ* operator ->() const { return &self; }
 };
+class CVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ {
+private:
+	LDKCVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ self;
+public:
+	CVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ(const CVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ&) = delete;
+	CVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ(CVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ)); }
+	CVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ(LDKCVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ)); }
+	operator LDKCVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ() && { LDKCVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ)); return res; }
+	~CVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ() { CVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ_free(self); }
+	CVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ& operator=(CVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ&& o) { CVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ)); return *this; }
+	LDKCVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ* operator &() { return &self; }
+	LDKCVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ* operator ->() { return &self; }
+	const LDKCVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ* operator &() const { return &self; }
+	const LDKCVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ* operator ->() const { return &self; }
+};
 class CResult_RouteHintHopDecodeErrorZ {
 private:
 	LDKCResult_RouteHintHopDecodeErrorZ self;
@@ -9626,6 +11873,21 @@ public:
 	const LDKCResult_RouteHintHopDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_RouteHintHopDecodeErrorZ* operator ->() const { return &self; }
 };
+class CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ {
+private:
+	LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ self;
+public:
+	CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ(const CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ&) = delete;
+	CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ(CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ)); }
+	CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ(LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ)); }
+	operator LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ() && { LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ)); return res; }
+	~CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ() { CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_free(self); }
+	CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ& operator=(CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ&& o) { CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ)); return *this; }
+	LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ* operator &() { return &self; }
+	LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ* operator ->() { return &self; }
+	const LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ* operator &() const { return &self; }
+	const LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ* operator ->() const { return &self; }
+};
 class CResult_UpdateFailMalformedHTLCDecodeErrorZ {
 private:
 	LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ self;
@@ -9686,20 +11948,35 @@ public:
 	const LDKCOption_ChannelShutdownStateZ* operator &() const { return &self; }
 	const LDKCOption_ChannelShutdownStateZ* operator ->() const { return &self; }
 };
-class CResult_CVec_CVec_u8ZZNoneZ {
+class CResult_Bolt12InvoiceBolt12SemanticErrorZ {
+private:
+	LDKCResult_Bolt12InvoiceBolt12SemanticErrorZ self;
+public:
+	CResult_Bolt12InvoiceBolt12SemanticErrorZ(const CResult_Bolt12InvoiceBolt12SemanticErrorZ&) = delete;
+	CResult_Bolt12InvoiceBolt12SemanticErrorZ(CResult_Bolt12InvoiceBolt12SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt12InvoiceBolt12SemanticErrorZ)); }
+	CResult_Bolt12InvoiceBolt12SemanticErrorZ(LDKCResult_Bolt12InvoiceBolt12SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt12InvoiceBolt12SemanticErrorZ)); }
+	operator LDKCResult_Bolt12InvoiceBolt12SemanticErrorZ() && { LDKCResult_Bolt12InvoiceBolt12SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt12InvoiceBolt12SemanticErrorZ)); return res; }
+	~CResult_Bolt12InvoiceBolt12SemanticErrorZ() { CResult_Bolt12InvoiceBolt12SemanticErrorZ_free(self); }
+	CResult_Bolt12InvoiceBolt12SemanticErrorZ& operator=(CResult_Bolt12InvoiceBolt12SemanticErrorZ&& o) { CResult_Bolt12InvoiceBolt12SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt12InvoiceBolt12SemanticErrorZ)); return *this; }
+	LDKCResult_Bolt12InvoiceBolt12SemanticErrorZ* operator &() { return &self; }
+	LDKCResult_Bolt12InvoiceBolt12SemanticErrorZ* operator ->() { return &self; }
+	const LDKCResult_Bolt12InvoiceBolt12SemanticErrorZ* operator &() const { return &self; }
+	const LDKCResult_Bolt12InvoiceBolt12SemanticErrorZ* operator ->() const { return &self; }
+};
+class CResult_InvoiceRequestFieldsDecodeErrorZ {
 private:
-	LDKCResult_CVec_CVec_u8ZZNoneZ self;
+	LDKCResult_InvoiceRequestFieldsDecodeErrorZ self;
 public:
-	CResult_CVec_CVec_u8ZZNoneZ(const CResult_CVec_CVec_u8ZZNoneZ&) = delete;
-	CResult_CVec_CVec_u8ZZNoneZ(CResult_CVec_CVec_u8ZZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_CVec_u8ZZNoneZ)); }
-	CResult_CVec_CVec_u8ZZNoneZ(LDKCResult_CVec_CVec_u8ZZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ)); }
-	operator LDKCResult_CVec_CVec_u8ZZNoneZ() && { LDKCResult_CVec_CVec_u8ZZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ)); return res; }
-	~CResult_CVec_CVec_u8ZZNoneZ() { CResult_CVec_CVec_u8ZZNoneZ_free(self); }
-	CResult_CVec_CVec_u8ZZNoneZ& operator=(CResult_CVec_CVec_u8ZZNoneZ&& o) { CResult_CVec_CVec_u8ZZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_CVec_u8ZZNoneZ)); return *this; }
-	LDKCResult_CVec_CVec_u8ZZNoneZ* operator &() { return &self; }
-	LDKCResult_CVec_CVec_u8ZZNoneZ* operator ->() { return &self; }
-	const LDKCResult_CVec_CVec_u8ZZNoneZ* operator &() const { return &self; }
-	const LDKCResult_CVec_CVec_u8ZZNoneZ* operator ->() const { return &self; }
+	CResult_InvoiceRequestFieldsDecodeErrorZ(const CResult_InvoiceRequestFieldsDecodeErrorZ&) = delete;
+	CResult_InvoiceRequestFieldsDecodeErrorZ(CResult_InvoiceRequestFieldsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceRequestFieldsDecodeErrorZ)); }
+	CResult_InvoiceRequestFieldsDecodeErrorZ(LDKCResult_InvoiceRequestFieldsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceRequestFieldsDecodeErrorZ)); }
+	operator LDKCResult_InvoiceRequestFieldsDecodeErrorZ() && { LDKCResult_InvoiceRequestFieldsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceRequestFieldsDecodeErrorZ)); return res; }
+	~CResult_InvoiceRequestFieldsDecodeErrorZ() { CResult_InvoiceRequestFieldsDecodeErrorZ_free(self); }
+	CResult_InvoiceRequestFieldsDecodeErrorZ& operator=(CResult_InvoiceRequestFieldsDecodeErrorZ&& o) { CResult_InvoiceRequestFieldsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceRequestFieldsDecodeErrorZ)); return *this; }
+	LDKCResult_InvoiceRequestFieldsDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_InvoiceRequestFieldsDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_InvoiceRequestFieldsDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_InvoiceRequestFieldsDecodeErrorZ* operator ->() const { return &self; }
 };
 class CResult_AcceptChannelDecodeErrorZ {
 private:
@@ -9716,6 +11993,21 @@ public:
 	const LDKCResult_AcceptChannelDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_AcceptChannelDecodeErrorZ* operator ->() const { return &self; }
 };
+class CResult_RefundDecodeErrorZ {
+private:
+	LDKCResult_RefundDecodeErrorZ self;
+public:
+	CResult_RefundDecodeErrorZ(const CResult_RefundDecodeErrorZ&) = delete;
+	CResult_RefundDecodeErrorZ(CResult_RefundDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RefundDecodeErrorZ)); }
+	CResult_RefundDecodeErrorZ(LDKCResult_RefundDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RefundDecodeErrorZ)); }
+	operator LDKCResult_RefundDecodeErrorZ() && { LDKCResult_RefundDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RefundDecodeErrorZ)); return res; }
+	~CResult_RefundDecodeErrorZ() { CResult_RefundDecodeErrorZ_free(self); }
+	CResult_RefundDecodeErrorZ& operator=(CResult_RefundDecodeErrorZ&& o) { CResult_RefundDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RefundDecodeErrorZ)); return *this; }
+	LDKCResult_RefundDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_RefundDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_RefundDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_RefundDecodeErrorZ* operator ->() const { return &self; }
+};
 class CResult_HostnameDecodeErrorZ {
 private:
 	LDKCResult_HostnameDecodeErrorZ self;
@@ -9791,35 +12083,65 @@ public:
 	const LDKCResult_NoneBolt12SemanticErrorZ* operator &() const { return &self; }
 	const LDKCResult_NoneBolt12SemanticErrorZ* operator ->() const { return &self; }
 };
-class COption_SecretKeyZ {
-private:
-	LDKCOption_SecretKeyZ self;
-public:
-	COption_SecretKeyZ(const COption_SecretKeyZ&) = delete;
-	COption_SecretKeyZ(COption_SecretKeyZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_SecretKeyZ)); }
-	COption_SecretKeyZ(LDKCOption_SecretKeyZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_SecretKeyZ)); }
-	operator LDKCOption_SecretKeyZ() && { LDKCOption_SecretKeyZ res = self; memset(&self, 0, sizeof(LDKCOption_SecretKeyZ)); return res; }
-	~COption_SecretKeyZ() { COption_SecretKeyZ_free(self); }
-	COption_SecretKeyZ& operator=(COption_SecretKeyZ&& o) { COption_SecretKeyZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_SecretKeyZ)); return *this; }
-	LDKCOption_SecretKeyZ* operator &() { return &self; }
-	LDKCOption_SecretKeyZ* operator ->() { return &self; }
-	const LDKCOption_SecretKeyZ* operator &() const { return &self; }
-	const LDKCOption_SecretKeyZ* operator ->() const { return &self; }
-};
-class CResult_ThirtyTwoBytesPaymentErrorZ {
-private:
-	LDKCResult_ThirtyTwoBytesPaymentErrorZ self;
-public:
-	CResult_ThirtyTwoBytesPaymentErrorZ(const CResult_ThirtyTwoBytesPaymentErrorZ&) = delete;
-	CResult_ThirtyTwoBytesPaymentErrorZ(CResult_ThirtyTwoBytesPaymentErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ThirtyTwoBytesPaymentErrorZ)); }
-	CResult_ThirtyTwoBytesPaymentErrorZ(LDKCResult_ThirtyTwoBytesPaymentErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ThirtyTwoBytesPaymentErrorZ)); }
-	operator LDKCResult_ThirtyTwoBytesPaymentErrorZ() && { LDKCResult_ThirtyTwoBytesPaymentErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ThirtyTwoBytesPaymentErrorZ)); return res; }
-	~CResult_ThirtyTwoBytesPaymentErrorZ() { CResult_ThirtyTwoBytesPaymentErrorZ_free(self); }
-	CResult_ThirtyTwoBytesPaymentErrorZ& operator=(CResult_ThirtyTwoBytesPaymentErrorZ&& o) { CResult_ThirtyTwoBytesPaymentErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ThirtyTwoBytesPaymentErrorZ)); return *this; }
-	LDKCResult_ThirtyTwoBytesPaymentErrorZ* operator &() { return &self; }
-	LDKCResult_ThirtyTwoBytesPaymentErrorZ* operator ->() { return &self; }
-	const LDKCResult_ThirtyTwoBytesPaymentErrorZ* operator &() const { return &self; }
-	const LDKCResult_ThirtyTwoBytesPaymentErrorZ* operator ->() const { return &self; }
+class CResult_UnknownPaymentContextDecodeErrorZ {
+private:
+	LDKCResult_UnknownPaymentContextDecodeErrorZ self;
+public:
+	CResult_UnknownPaymentContextDecodeErrorZ(const CResult_UnknownPaymentContextDecodeErrorZ&) = delete;
+	CResult_UnknownPaymentContextDecodeErrorZ(CResult_UnknownPaymentContextDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnknownPaymentContextDecodeErrorZ)); }
+	CResult_UnknownPaymentContextDecodeErrorZ(LDKCResult_UnknownPaymentContextDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnknownPaymentContextDecodeErrorZ)); }
+	operator LDKCResult_UnknownPaymentContextDecodeErrorZ() && { LDKCResult_UnknownPaymentContextDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnknownPaymentContextDecodeErrorZ)); return res; }
+	~CResult_UnknownPaymentContextDecodeErrorZ() { CResult_UnknownPaymentContextDecodeErrorZ_free(self); }
+	CResult_UnknownPaymentContextDecodeErrorZ& operator=(CResult_UnknownPaymentContextDecodeErrorZ&& o) { CResult_UnknownPaymentContextDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnknownPaymentContextDecodeErrorZ)); return *this; }
+	LDKCResult_UnknownPaymentContextDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_UnknownPaymentContextDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_UnknownPaymentContextDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_UnknownPaymentContextDecodeErrorZ* operator ->() const { return &self; }
+};
+class COption_InboundHTLCStateDetailsZ {
+private:
+	LDKCOption_InboundHTLCStateDetailsZ self;
+public:
+	COption_InboundHTLCStateDetailsZ(const COption_InboundHTLCStateDetailsZ&) = delete;
+	COption_InboundHTLCStateDetailsZ(COption_InboundHTLCStateDetailsZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_InboundHTLCStateDetailsZ)); }
+	COption_InboundHTLCStateDetailsZ(LDKCOption_InboundHTLCStateDetailsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_InboundHTLCStateDetailsZ)); }
+	operator LDKCOption_InboundHTLCStateDetailsZ() && { LDKCOption_InboundHTLCStateDetailsZ res = self; memset(&self, 0, sizeof(LDKCOption_InboundHTLCStateDetailsZ)); return res; }
+	~COption_InboundHTLCStateDetailsZ() { COption_InboundHTLCStateDetailsZ_free(self); }
+	COption_InboundHTLCStateDetailsZ& operator=(COption_InboundHTLCStateDetailsZ&& o) { COption_InboundHTLCStateDetailsZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_InboundHTLCStateDetailsZ)); return *this; }
+	LDKCOption_InboundHTLCStateDetailsZ* operator &() { return &self; }
+	LDKCOption_InboundHTLCStateDetailsZ* operator ->() { return &self; }
+	const LDKCOption_InboundHTLCStateDetailsZ* operator &() const { return &self; }
+	const LDKCOption_InboundHTLCStateDetailsZ* operator ->() const { return &self; }
+};
+class CResult_OutputSweeperDecodeErrorZ {
+private:
+	LDKCResult_OutputSweeperDecodeErrorZ self;
+public:
+	CResult_OutputSweeperDecodeErrorZ(const CResult_OutputSweeperDecodeErrorZ&) = delete;
+	CResult_OutputSweeperDecodeErrorZ(CResult_OutputSweeperDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OutputSweeperDecodeErrorZ)); }
+	CResult_OutputSweeperDecodeErrorZ(LDKCResult_OutputSweeperDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OutputSweeperDecodeErrorZ)); }
+	operator LDKCResult_OutputSweeperDecodeErrorZ() && { LDKCResult_OutputSweeperDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OutputSweeperDecodeErrorZ)); return res; }
+	~CResult_OutputSweeperDecodeErrorZ() { CResult_OutputSweeperDecodeErrorZ_free(self); }
+	CResult_OutputSweeperDecodeErrorZ& operator=(CResult_OutputSweeperDecodeErrorZ&& o) { CResult_OutputSweeperDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OutputSweeperDecodeErrorZ)); return *this; }
+	LDKCResult_OutputSweeperDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_OutputSweeperDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_OutputSweeperDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_OutputSweeperDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_C2Tuple_CVec_u8Zu64ZNoneZ {
+private:
+	LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ self;
+public:
+	CResult_C2Tuple_CVec_u8Zu64ZNoneZ(const CResult_C2Tuple_CVec_u8Zu64ZNoneZ&) = delete;
+	CResult_C2Tuple_CVec_u8Zu64ZNoneZ(CResult_C2Tuple_CVec_u8Zu64ZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_CVec_u8Zu64ZNoneZ)); }
+	CResult_C2Tuple_CVec_u8Zu64ZNoneZ(LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ)); }
+	operator LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ() && { LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ)); return res; }
+	~CResult_C2Tuple_CVec_u8Zu64ZNoneZ() { CResult_C2Tuple_CVec_u8Zu64ZNoneZ_free(self); }
+	CResult_C2Tuple_CVec_u8Zu64ZNoneZ& operator=(CResult_C2Tuple_CVec_u8Zu64ZNoneZ&& o) { CResult_C2Tuple_CVec_u8Zu64ZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_CVec_u8Zu64ZNoneZ)); return *this; }
+	LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ* operator &() { return &self; }
+	LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ* operator ->() { return &self; }
+	const LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ* operator &() const { return &self; }
+	const LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ* operator ->() const { return &self; }
 };
 class COption_EventZ {
 private:
@@ -9911,6 +12233,21 @@ public:
 	const LDKCOption_PaymentFailureReasonZ* operator &() const { return &self; }
 	const LDKCOption_PaymentFailureReasonZ* operator ->() const { return &self; }
 };
+class CResult_Bolt12RefundContextDecodeErrorZ {
+private:
+	LDKCResult_Bolt12RefundContextDecodeErrorZ self;
+public:
+	CResult_Bolt12RefundContextDecodeErrorZ(const CResult_Bolt12RefundContextDecodeErrorZ&) = delete;
+	CResult_Bolt12RefundContextDecodeErrorZ(CResult_Bolt12RefundContextDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt12RefundContextDecodeErrorZ)); }
+	CResult_Bolt12RefundContextDecodeErrorZ(LDKCResult_Bolt12RefundContextDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt12RefundContextDecodeErrorZ)); }
+	operator LDKCResult_Bolt12RefundContextDecodeErrorZ() && { LDKCResult_Bolt12RefundContextDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt12RefundContextDecodeErrorZ)); return res; }
+	~CResult_Bolt12RefundContextDecodeErrorZ() { CResult_Bolt12RefundContextDecodeErrorZ_free(self); }
+	CResult_Bolt12RefundContextDecodeErrorZ& operator=(CResult_Bolt12RefundContextDecodeErrorZ&& o) { CResult_Bolt12RefundContextDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt12RefundContextDecodeErrorZ)); return *this; }
+	LDKCResult_Bolt12RefundContextDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_Bolt12RefundContextDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_Bolt12RefundContextDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_Bolt12RefundContextDecodeErrorZ* operator ->() const { return &self; }
+};
 class CResult_ECDSASignatureNoneZ {
 private:
 	LDKCResult_ECDSASignatureNoneZ self;
@@ -9926,20 +12263,50 @@ public:
 	const LDKCResult_ECDSASignatureNoneZ* operator &() const { return &self; }
 	const LDKCResult_ECDSASignatureNoneZ* operator ->() const { return &self; }
 };
-class CVec_WitnessZ {
-private:
-	LDKCVec_WitnessZ self;
-public:
-	CVec_WitnessZ(const CVec_WitnessZ&) = delete;
-	CVec_WitnessZ(CVec_WitnessZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_WitnessZ)); }
-	CVec_WitnessZ(LDKCVec_WitnessZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_WitnessZ)); }
-	operator LDKCVec_WitnessZ() && { LDKCVec_WitnessZ res = self; memset(&self, 0, sizeof(LDKCVec_WitnessZ)); return res; }
-	~CVec_WitnessZ() { CVec_WitnessZ_free(self); }
-	CVec_WitnessZ& operator=(CVec_WitnessZ&& o) { CVec_WitnessZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_WitnessZ)); return *this; }
-	LDKCVec_WitnessZ* operator &() { return &self; }
-	LDKCVec_WitnessZ* operator ->() { return &self; }
-	const LDKCVec_WitnessZ* operator &() const { return &self; }
-	const LDKCVec_WitnessZ* operator ->() const { return &self; }
+class C2Tuple_ChannelIdPublicKeyZ {
+private:
+	LDKC2Tuple_ChannelIdPublicKeyZ self;
+public:
+	C2Tuple_ChannelIdPublicKeyZ(const C2Tuple_ChannelIdPublicKeyZ&) = delete;
+	C2Tuple_ChannelIdPublicKeyZ(C2Tuple_ChannelIdPublicKeyZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ChannelIdPublicKeyZ)); }
+	C2Tuple_ChannelIdPublicKeyZ(LDKC2Tuple_ChannelIdPublicKeyZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ChannelIdPublicKeyZ)); }
+	operator LDKC2Tuple_ChannelIdPublicKeyZ() && { LDKC2Tuple_ChannelIdPublicKeyZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ChannelIdPublicKeyZ)); return res; }
+	~C2Tuple_ChannelIdPublicKeyZ() { C2Tuple_ChannelIdPublicKeyZ_free(self); }
+	C2Tuple_ChannelIdPublicKeyZ& operator=(C2Tuple_ChannelIdPublicKeyZ&& o) { C2Tuple_ChannelIdPublicKeyZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_ChannelIdPublicKeyZ)); return *this; }
+	LDKC2Tuple_ChannelIdPublicKeyZ* operator &() { return &self; }
+	LDKC2Tuple_ChannelIdPublicKeyZ* operator ->() { return &self; }
+	const LDKC2Tuple_ChannelIdPublicKeyZ* operator &() const { return &self; }
+	const LDKC2Tuple_ChannelIdPublicKeyZ* operator ->() const { return &self; }
+};
+class C2Tuple_OffersMessageResponseInstructionZ {
+private:
+	LDKC2Tuple_OffersMessageResponseInstructionZ self;
+public:
+	C2Tuple_OffersMessageResponseInstructionZ(const C2Tuple_OffersMessageResponseInstructionZ&) = delete;
+	C2Tuple_OffersMessageResponseInstructionZ(C2Tuple_OffersMessageResponseInstructionZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_OffersMessageResponseInstructionZ)); }
+	C2Tuple_OffersMessageResponseInstructionZ(LDKC2Tuple_OffersMessageResponseInstructionZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_OffersMessageResponseInstructionZ)); }
+	operator LDKC2Tuple_OffersMessageResponseInstructionZ() && { LDKC2Tuple_OffersMessageResponseInstructionZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_OffersMessageResponseInstructionZ)); return res; }
+	~C2Tuple_OffersMessageResponseInstructionZ() { C2Tuple_OffersMessageResponseInstructionZ_free(self); }
+	C2Tuple_OffersMessageResponseInstructionZ& operator=(C2Tuple_OffersMessageResponseInstructionZ&& o) { C2Tuple_OffersMessageResponseInstructionZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_OffersMessageResponseInstructionZ)); return *this; }
+	LDKC2Tuple_OffersMessageResponseInstructionZ* operator &() { return &self; }
+	LDKC2Tuple_OffersMessageResponseInstructionZ* operator ->() { return &self; }
+	const LDKC2Tuple_OffersMessageResponseInstructionZ* operator &() const { return &self; }
+	const LDKC2Tuple_OffersMessageResponseInstructionZ* operator ->() const { return &self; }
+};
+class CResult_EcdsaChannelSignerDecodeErrorZ {
+private:
+	LDKCResult_EcdsaChannelSignerDecodeErrorZ self;
+public:
+	CResult_EcdsaChannelSignerDecodeErrorZ(const CResult_EcdsaChannelSignerDecodeErrorZ&) = delete;
+	CResult_EcdsaChannelSignerDecodeErrorZ(CResult_EcdsaChannelSignerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_EcdsaChannelSignerDecodeErrorZ)); }
+	CResult_EcdsaChannelSignerDecodeErrorZ(LDKCResult_EcdsaChannelSignerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_EcdsaChannelSignerDecodeErrorZ)); }
+	operator LDKCResult_EcdsaChannelSignerDecodeErrorZ() && { LDKCResult_EcdsaChannelSignerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_EcdsaChannelSignerDecodeErrorZ)); return res; }
+	~CResult_EcdsaChannelSignerDecodeErrorZ() { CResult_EcdsaChannelSignerDecodeErrorZ_free(self); }
+	CResult_EcdsaChannelSignerDecodeErrorZ& operator=(CResult_EcdsaChannelSignerDecodeErrorZ&& o) { CResult_EcdsaChannelSignerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_EcdsaChannelSignerDecodeErrorZ)); return *this; }
+	LDKCResult_EcdsaChannelSignerDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_EcdsaChannelSignerDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_EcdsaChannelSignerDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_EcdsaChannelSignerDecodeErrorZ* operator ->() const { return &self; }
 };
 class CResult_BlindedTailDecodeErrorZ {
 private:
@@ -9956,20 +12323,20 @@ public:
 	const LDKCResult_BlindedTailDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_BlindedTailDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_SocketAddressSocketAddressParseErrorZ {
+class CVec_WitnessZ {
 private:
-	LDKCResult_SocketAddressSocketAddressParseErrorZ self;
+	LDKCVec_WitnessZ self;
 public:
-	CResult_SocketAddressSocketAddressParseErrorZ(const CResult_SocketAddressSocketAddressParseErrorZ&) = delete;
-	CResult_SocketAddressSocketAddressParseErrorZ(CResult_SocketAddressSocketAddressParseErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SocketAddressSocketAddressParseErrorZ)); }
-	CResult_SocketAddressSocketAddressParseErrorZ(LDKCResult_SocketAddressSocketAddressParseErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SocketAddressSocketAddressParseErrorZ)); }
-	operator LDKCResult_SocketAddressSocketAddressParseErrorZ() && { LDKCResult_SocketAddressSocketAddressParseErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SocketAddressSocketAddressParseErrorZ)); return res; }
-	~CResult_SocketAddressSocketAddressParseErrorZ() { CResult_SocketAddressSocketAddressParseErrorZ_free(self); }
-	CResult_SocketAddressSocketAddressParseErrorZ& operator=(CResult_SocketAddressSocketAddressParseErrorZ&& o) { CResult_SocketAddressSocketAddressParseErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SocketAddressSocketAddressParseErrorZ)); return *this; }
-	LDKCResult_SocketAddressSocketAddressParseErrorZ* operator &() { return &self; }
-	LDKCResult_SocketAddressSocketAddressParseErrorZ* operator ->() { return &self; }
-	const LDKCResult_SocketAddressSocketAddressParseErrorZ* operator &() const { return &self; }
-	const LDKCResult_SocketAddressSocketAddressParseErrorZ* operator ->() const { return &self; }
+	CVec_WitnessZ(const CVec_WitnessZ&) = delete;
+	CVec_WitnessZ(CVec_WitnessZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_WitnessZ)); }
+	CVec_WitnessZ(LDKCVec_WitnessZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_WitnessZ)); }
+	operator LDKCVec_WitnessZ() && { LDKCVec_WitnessZ res = self; memset(&self, 0, sizeof(LDKCVec_WitnessZ)); return res; }
+	~CVec_WitnessZ() { CVec_WitnessZ_free(self); }
+	CVec_WitnessZ& operator=(CVec_WitnessZ&& o) { CVec_WitnessZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_WitnessZ)); return *this; }
+	LDKCVec_WitnessZ* operator &() { return &self; }
+	LDKCVec_WitnessZ* operator ->() { return &self; }
+	const LDKCVec_WitnessZ* operator &() const { return &self; }
+	const LDKCVec_WitnessZ* operator ->() const { return &self; }
 };
 class COption_C2Tuple_u64u16ZZ {
 private:
@@ -9986,20 +12353,35 @@ public:
 	const LDKCOption_C2Tuple_u64u16ZZ* operator &() const { return &self; }
 	const LDKCOption_C2Tuple_u64u16ZZ* operator ->() const { return &self; }
 };
-class CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ {
+class CResult_SocketAddressSocketAddressParseErrorZ {
 private:
-	LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ self;
+	LDKCResult_SocketAddressSocketAddressParseErrorZ self;
 public:
-	CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ(const CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ&) = delete;
-	CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ(CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ)); }
-	CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ)); }
-	operator LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ() && { LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ)); return res; }
-	~CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ() { CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_free(self); }
-	CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ& operator=(CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ&& o) { CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ)); return *this; }
-	LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* operator &() { return &self; }
-	LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* operator ->() { return &self; }
-	const LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* operator &() const { return &self; }
-	const LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* operator ->() const { return &self; }
+	CResult_SocketAddressSocketAddressParseErrorZ(const CResult_SocketAddressSocketAddressParseErrorZ&) = delete;
+	CResult_SocketAddressSocketAddressParseErrorZ(CResult_SocketAddressSocketAddressParseErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SocketAddressSocketAddressParseErrorZ)); }
+	CResult_SocketAddressSocketAddressParseErrorZ(LDKCResult_SocketAddressSocketAddressParseErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SocketAddressSocketAddressParseErrorZ)); }
+	operator LDKCResult_SocketAddressSocketAddressParseErrorZ() && { LDKCResult_SocketAddressSocketAddressParseErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SocketAddressSocketAddressParseErrorZ)); return res; }
+	~CResult_SocketAddressSocketAddressParseErrorZ() { CResult_SocketAddressSocketAddressParseErrorZ_free(self); }
+	CResult_SocketAddressSocketAddressParseErrorZ& operator=(CResult_SocketAddressSocketAddressParseErrorZ&& o) { CResult_SocketAddressSocketAddressParseErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SocketAddressSocketAddressParseErrorZ)); return *this; }
+	LDKCResult_SocketAddressSocketAddressParseErrorZ* operator &() { return &self; }
+	LDKCResult_SocketAddressSocketAddressParseErrorZ* operator ->() { return &self; }
+	const LDKCResult_SocketAddressSocketAddressParseErrorZ* operator &() const { return &self; }
+	const LDKCResult_SocketAddressSocketAddressParseErrorZ* operator ->() const { return &self; }
+};
+class CResult_COption_PaymentFailureReasonZDecodeErrorZ {
+private:
+	LDKCResult_COption_PaymentFailureReasonZDecodeErrorZ self;
+public:
+	CResult_COption_PaymentFailureReasonZDecodeErrorZ(const CResult_COption_PaymentFailureReasonZDecodeErrorZ&) = delete;
+	CResult_COption_PaymentFailureReasonZDecodeErrorZ(CResult_COption_PaymentFailureReasonZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_PaymentFailureReasonZDecodeErrorZ)); }
+	CResult_COption_PaymentFailureReasonZDecodeErrorZ(LDKCResult_COption_PaymentFailureReasonZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_PaymentFailureReasonZDecodeErrorZ)); }
+	operator LDKCResult_COption_PaymentFailureReasonZDecodeErrorZ() && { LDKCResult_COption_PaymentFailureReasonZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_PaymentFailureReasonZDecodeErrorZ)); return res; }
+	~CResult_COption_PaymentFailureReasonZDecodeErrorZ() { CResult_COption_PaymentFailureReasonZDecodeErrorZ_free(self); }
+	CResult_COption_PaymentFailureReasonZDecodeErrorZ& operator=(CResult_COption_PaymentFailureReasonZDecodeErrorZ&& o) { CResult_COption_PaymentFailureReasonZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_PaymentFailureReasonZDecodeErrorZ)); return *this; }
+	LDKCResult_COption_PaymentFailureReasonZDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_COption_PaymentFailureReasonZDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_COption_PaymentFailureReasonZDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_COption_PaymentFailureReasonZDecodeErrorZ* operator ->() const { return &self; }
 };
 class CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ {
 private:
@@ -10031,20 +12413,50 @@ public:
 	const LDKCResult_ChannelDerivationParametersDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_ChannelDerivationParametersDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_PaymentConstraintsDecodeErrorZ {
+class CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ {
 private:
-	LDKCResult_PaymentConstraintsDecodeErrorZ self;
+	LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ self;
 public:
-	CResult_PaymentConstraintsDecodeErrorZ(const CResult_PaymentConstraintsDecodeErrorZ&) = delete;
-	CResult_PaymentConstraintsDecodeErrorZ(CResult_PaymentConstraintsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentConstraintsDecodeErrorZ)); }
-	CResult_PaymentConstraintsDecodeErrorZ(LDKCResult_PaymentConstraintsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentConstraintsDecodeErrorZ)); }
-	operator LDKCResult_PaymentConstraintsDecodeErrorZ() && { LDKCResult_PaymentConstraintsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentConstraintsDecodeErrorZ)); return res; }
-	~CResult_PaymentConstraintsDecodeErrorZ() { CResult_PaymentConstraintsDecodeErrorZ_free(self); }
-	CResult_PaymentConstraintsDecodeErrorZ& operator=(CResult_PaymentConstraintsDecodeErrorZ&& o) { CResult_PaymentConstraintsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentConstraintsDecodeErrorZ)); return *this; }
-	LDKCResult_PaymentConstraintsDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_PaymentConstraintsDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_PaymentConstraintsDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_PaymentConstraintsDecodeErrorZ* operator ->() const { return &self; }
+	CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ(const CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ&) = delete;
+	CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ(CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ)); }
+	CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ)); }
+	operator LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ() && { LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ)); return res; }
+	~CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ() { CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_free(self); }
+	CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ& operator=(CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ&& o) { CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ)); return *this; }
+	LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* operator &() { return &self; }
+	LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* operator ->() { return &self; }
+	const LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* operator &() const { return &self; }
+	const LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* operator ->() const { return &self; }
+};
+class CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ {
+private:
+	LDKCResult_UnsignedInvoiceRequestBolt12SemanticErrorZ self;
+public:
+	CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ(const CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ&) = delete;
+	CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ(CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ)); }
+	CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ(LDKCResult_UnsignedInvoiceRequestBolt12SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnsignedInvoiceRequestBolt12SemanticErrorZ)); }
+	operator LDKCResult_UnsignedInvoiceRequestBolt12SemanticErrorZ() && { LDKCResult_UnsignedInvoiceRequestBolt12SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnsignedInvoiceRequestBolt12SemanticErrorZ)); return res; }
+	~CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ() { CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ_free(self); }
+	CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ& operator=(CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ&& o) { CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ)); return *this; }
+	LDKCResult_UnsignedInvoiceRequestBolt12SemanticErrorZ* operator &() { return &self; }
+	LDKCResult_UnsignedInvoiceRequestBolt12SemanticErrorZ* operator ->() { return &self; }
+	const LDKCResult_UnsignedInvoiceRequestBolt12SemanticErrorZ* operator &() const { return &self; }
+	const LDKCResult_UnsignedInvoiceRequestBolt12SemanticErrorZ* operator ->() const { return &self; }
+};
+class CResult_OnionMessagePathNoneZ {
+private:
+	LDKCResult_OnionMessagePathNoneZ self;
+public:
+	CResult_OnionMessagePathNoneZ(const CResult_OnionMessagePathNoneZ&) = delete;
+	CResult_OnionMessagePathNoneZ(CResult_OnionMessagePathNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OnionMessagePathNoneZ)); }
+	CResult_OnionMessagePathNoneZ(LDKCResult_OnionMessagePathNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OnionMessagePathNoneZ)); }
+	operator LDKCResult_OnionMessagePathNoneZ() && { LDKCResult_OnionMessagePathNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_OnionMessagePathNoneZ)); return res; }
+	~CResult_OnionMessagePathNoneZ() { CResult_OnionMessagePathNoneZ_free(self); }
+	CResult_OnionMessagePathNoneZ& operator=(CResult_OnionMessagePathNoneZ&& o) { CResult_OnionMessagePathNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OnionMessagePathNoneZ)); return *this; }
+	LDKCResult_OnionMessagePathNoneZ* operator &() { return &self; }
+	LDKCResult_OnionMessagePathNoneZ* operator ->() { return &self; }
+	const LDKCResult_OnionMessagePathNoneZ* operator &() const { return &self; }
+	const LDKCResult_OnionMessagePathNoneZ* operator ->() const { return &self; }
 };
 class C2Tuple_u32CVec_u8ZZ {
 private:
@@ -10076,20 +12488,20 @@ public:
 	const LDKCVec_C2Tuple_PublicKeyTypeZZ* operator &() const { return &self; }
 	const LDKCVec_C2Tuple_PublicKeyTypeZZ* operator ->() const { return &self; }
 };
-class CResult_OnionMessagePathNoneZ {
+class CResult_OutboundHTLCDetailsDecodeErrorZ {
 private:
-	LDKCResult_OnionMessagePathNoneZ self;
+	LDKCResult_OutboundHTLCDetailsDecodeErrorZ self;
 public:
-	CResult_OnionMessagePathNoneZ(const CResult_OnionMessagePathNoneZ&) = delete;
-	CResult_OnionMessagePathNoneZ(CResult_OnionMessagePathNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OnionMessagePathNoneZ)); }
-	CResult_OnionMessagePathNoneZ(LDKCResult_OnionMessagePathNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OnionMessagePathNoneZ)); }
-	operator LDKCResult_OnionMessagePathNoneZ() && { LDKCResult_OnionMessagePathNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_OnionMessagePathNoneZ)); return res; }
-	~CResult_OnionMessagePathNoneZ() { CResult_OnionMessagePathNoneZ_free(self); }
-	CResult_OnionMessagePathNoneZ& operator=(CResult_OnionMessagePathNoneZ&& o) { CResult_OnionMessagePathNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OnionMessagePathNoneZ)); return *this; }
-	LDKCResult_OnionMessagePathNoneZ* operator &() { return &self; }
-	LDKCResult_OnionMessagePathNoneZ* operator ->() { return &self; }
-	const LDKCResult_OnionMessagePathNoneZ* operator &() const { return &self; }
-	const LDKCResult_OnionMessagePathNoneZ* operator ->() const { return &self; }
+	CResult_OutboundHTLCDetailsDecodeErrorZ(const CResult_OutboundHTLCDetailsDecodeErrorZ&) = delete;
+	CResult_OutboundHTLCDetailsDecodeErrorZ(CResult_OutboundHTLCDetailsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OutboundHTLCDetailsDecodeErrorZ)); }
+	CResult_OutboundHTLCDetailsDecodeErrorZ(LDKCResult_OutboundHTLCDetailsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OutboundHTLCDetailsDecodeErrorZ)); }
+	operator LDKCResult_OutboundHTLCDetailsDecodeErrorZ() && { LDKCResult_OutboundHTLCDetailsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OutboundHTLCDetailsDecodeErrorZ)); return res; }
+	~CResult_OutboundHTLCDetailsDecodeErrorZ() { CResult_OutboundHTLCDetailsDecodeErrorZ_free(self); }
+	CResult_OutboundHTLCDetailsDecodeErrorZ& operator=(CResult_OutboundHTLCDetailsDecodeErrorZ&& o) { CResult_OutboundHTLCDetailsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OutboundHTLCDetailsDecodeErrorZ)); return *this; }
+	LDKCResult_OutboundHTLCDetailsDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_OutboundHTLCDetailsDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_OutboundHTLCDetailsDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_OutboundHTLCDetailsDecodeErrorZ* operator ->() const { return &self; }
 };
 class CResult_RefundBolt12ParseErrorZ {
 private:
@@ -10106,20 +12518,20 @@ public:
 	const LDKCResult_RefundBolt12ParseErrorZ* operator &() const { return &self; }
 	const LDKCResult_RefundBolt12ParseErrorZ* operator ->() const { return &self; }
 };
-class C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ {
+class CResult_u32GraphSyncErrorZ {
 private:
-	LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ self;
+	LDKCResult_u32GraphSyncErrorZ self;
 public:
-	C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ(const C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ&) = delete;
-	C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ(C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ)); }
-	C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ)); }
-	operator LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ() && { LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ)); return res; }
-	~C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ() { C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(self); }
-	C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ& operator=(C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ&& o) { C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(self); self = o.self; memset(&o, 0, sizeof(C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ)); return *this; }
-	LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* operator &() { return &self; }
-	LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* operator ->() { return &self; }
-	const LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* operator &() const { return &self; }
-	const LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* operator ->() const { return &self; }
+	CResult_u32GraphSyncErrorZ(const CResult_u32GraphSyncErrorZ&) = delete;
+	CResult_u32GraphSyncErrorZ(CResult_u32GraphSyncErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_u32GraphSyncErrorZ)); }
+	CResult_u32GraphSyncErrorZ(LDKCResult_u32GraphSyncErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_u32GraphSyncErrorZ)); }
+	operator LDKCResult_u32GraphSyncErrorZ() && { LDKCResult_u32GraphSyncErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_u32GraphSyncErrorZ)); return res; }
+	~CResult_u32GraphSyncErrorZ() { CResult_u32GraphSyncErrorZ_free(self); }
+	CResult_u32GraphSyncErrorZ& operator=(CResult_u32GraphSyncErrorZ&& o) { CResult_u32GraphSyncErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_u32GraphSyncErrorZ)); return *this; }
+	LDKCResult_u32GraphSyncErrorZ* operator &() { return &self; }
+	LDKCResult_u32GraphSyncErrorZ* operator ->() { return &self; }
+	const LDKCResult_u32GraphSyncErrorZ* operator &() const { return &self; }
+	const LDKCResult_u32GraphSyncErrorZ* operator ->() const { return &self; }
 };
 class CVec_C2Tuple_u64CVec_u8ZZZ {
 private:
@@ -10136,35 +12548,35 @@ public:
 	const LDKCVec_C2Tuple_u64CVec_u8ZZZ* operator &() const { return &self; }
 	const LDKCVec_C2Tuple_u64CVec_u8ZZZ* operator ->() const { return &self; }
 };
-class CResult_u32GraphSyncErrorZ {
+class CResult_OffersMessageDecodeErrorZ {
 private:
-	LDKCResult_u32GraphSyncErrorZ self;
+	LDKCResult_OffersMessageDecodeErrorZ self;
 public:
-	CResult_u32GraphSyncErrorZ(const CResult_u32GraphSyncErrorZ&) = delete;
-	CResult_u32GraphSyncErrorZ(CResult_u32GraphSyncErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_u32GraphSyncErrorZ)); }
-	CResult_u32GraphSyncErrorZ(LDKCResult_u32GraphSyncErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_u32GraphSyncErrorZ)); }
-	operator LDKCResult_u32GraphSyncErrorZ() && { LDKCResult_u32GraphSyncErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_u32GraphSyncErrorZ)); return res; }
-	~CResult_u32GraphSyncErrorZ() { CResult_u32GraphSyncErrorZ_free(self); }
-	CResult_u32GraphSyncErrorZ& operator=(CResult_u32GraphSyncErrorZ&& o) { CResult_u32GraphSyncErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_u32GraphSyncErrorZ)); return *this; }
-	LDKCResult_u32GraphSyncErrorZ* operator &() { return &self; }
-	LDKCResult_u32GraphSyncErrorZ* operator ->() { return &self; }
-	const LDKCResult_u32GraphSyncErrorZ* operator &() const { return &self; }
-	const LDKCResult_u32GraphSyncErrorZ* operator ->() const { return &self; }
+	CResult_OffersMessageDecodeErrorZ(const CResult_OffersMessageDecodeErrorZ&) = delete;
+	CResult_OffersMessageDecodeErrorZ(CResult_OffersMessageDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OffersMessageDecodeErrorZ)); }
+	CResult_OffersMessageDecodeErrorZ(LDKCResult_OffersMessageDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OffersMessageDecodeErrorZ)); }
+	operator LDKCResult_OffersMessageDecodeErrorZ() && { LDKCResult_OffersMessageDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OffersMessageDecodeErrorZ)); return res; }
+	~CResult_OffersMessageDecodeErrorZ() { CResult_OffersMessageDecodeErrorZ_free(self); }
+	CResult_OffersMessageDecodeErrorZ& operator=(CResult_OffersMessageDecodeErrorZ&& o) { CResult_OffersMessageDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OffersMessageDecodeErrorZ)); return *this; }
+	LDKCResult_OffersMessageDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_OffersMessageDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_OffersMessageDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_OffersMessageDecodeErrorZ* operator ->() const { return &self; }
 };
-class CVec_PhantomRouteHintsZ {
+class CResult_PaymentConstraintsDecodeErrorZ {
 private:
-	LDKCVec_PhantomRouteHintsZ self;
+	LDKCResult_PaymentConstraintsDecodeErrorZ 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; }
+	CResult_PaymentConstraintsDecodeErrorZ(const CResult_PaymentConstraintsDecodeErrorZ&) = delete;
+	CResult_PaymentConstraintsDecodeErrorZ(CResult_PaymentConstraintsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentConstraintsDecodeErrorZ)); }
+	CResult_PaymentConstraintsDecodeErrorZ(LDKCResult_PaymentConstraintsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentConstraintsDecodeErrorZ)); }
+	operator LDKCResult_PaymentConstraintsDecodeErrorZ() && { LDKCResult_PaymentConstraintsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentConstraintsDecodeErrorZ)); return res; }
+	~CResult_PaymentConstraintsDecodeErrorZ() { CResult_PaymentConstraintsDecodeErrorZ_free(self); }
+	CResult_PaymentConstraintsDecodeErrorZ& operator=(CResult_PaymentConstraintsDecodeErrorZ&& o) { CResult_PaymentConstraintsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentConstraintsDecodeErrorZ)); return *this; }
+	LDKCResult_PaymentConstraintsDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_PaymentConstraintsDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_PaymentConstraintsDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_PaymentConstraintsDecodeErrorZ* operator ->() const { return &self; }
 };
 class CResult_NoneAPIErrorZ {
 private:
@@ -10211,20 +12623,20 @@ public:
 	const LDKCOption_f64Z* operator &() const { return &self; }
 	const LDKCOption_f64Z* operator ->() const { return &self; }
 };
-class CResult_ChannelDetailsDecodeErrorZ {
+class CResult_TxRemoveInputDecodeErrorZ {
 private:
-	LDKCResult_ChannelDetailsDecodeErrorZ self;
+	LDKCResult_TxRemoveInputDecodeErrorZ 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; }
+	CResult_TxRemoveInputDecodeErrorZ(const CResult_TxRemoveInputDecodeErrorZ&) = delete;
+	CResult_TxRemoveInputDecodeErrorZ(CResult_TxRemoveInputDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxRemoveInputDecodeErrorZ)); }
+	CResult_TxRemoveInputDecodeErrorZ(LDKCResult_TxRemoveInputDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxRemoveInputDecodeErrorZ)); }
+	operator LDKCResult_TxRemoveInputDecodeErrorZ() && { LDKCResult_TxRemoveInputDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxRemoveInputDecodeErrorZ)); return res; }
+	~CResult_TxRemoveInputDecodeErrorZ() { CResult_TxRemoveInputDecodeErrorZ_free(self); }
+	CResult_TxRemoveInputDecodeErrorZ& operator=(CResult_TxRemoveInputDecodeErrorZ&& o) { CResult_TxRemoveInputDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxRemoveInputDecodeErrorZ)); return *this; }
+	LDKCResult_TxRemoveInputDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_TxRemoveInputDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_TxRemoveInputDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_TxRemoveInputDecodeErrorZ* operator ->() const { return &self; }
 };
 class CVec_PublicKeyZ {
 private:
@@ -10241,6 +12653,21 @@ public:
 	const LDKCVec_PublicKeyZ* operator &() const { return &self; }
 	const LDKCVec_PublicKeyZ* operator ->() const { return &self; }
 };
+class C2Tuple_CVec_u8Zu64Z {
+private:
+	LDKC2Tuple_CVec_u8Zu64Z self;
+public:
+	C2Tuple_CVec_u8Zu64Z(const C2Tuple_CVec_u8Zu64Z&) = delete;
+	C2Tuple_CVec_u8Zu64Z(C2Tuple_CVec_u8Zu64Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_CVec_u8Zu64Z)); }
+	C2Tuple_CVec_u8Zu64Z(LDKC2Tuple_CVec_u8Zu64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_CVec_u8Zu64Z)); }
+	operator LDKC2Tuple_CVec_u8Zu64Z() && { LDKC2Tuple_CVec_u8Zu64Z res = self; memset(&self, 0, sizeof(LDKC2Tuple_CVec_u8Zu64Z)); return res; }
+	~C2Tuple_CVec_u8Zu64Z() { C2Tuple_CVec_u8Zu64Z_free(self); }
+	C2Tuple_CVec_u8Zu64Z& operator=(C2Tuple_CVec_u8Zu64Z&& o) { C2Tuple_CVec_u8Zu64Z_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_CVec_u8Zu64Z)); return *this; }
+	LDKC2Tuple_CVec_u8Zu64Z* operator &() { return &self; }
+	LDKC2Tuple_CVec_u8Zu64Z* operator ->() { return &self; }
+	const LDKC2Tuple_CVec_u8Zu64Z* operator &() const { return &self; }
+	const LDKC2Tuple_CVec_u8Zu64Z* operator ->() const { return &self; }
+};
 class CVec_C2Tuple_usizeTransactionZZ {
 private:
 	LDKCVec_C2Tuple_usizeTransactionZZ self;
@@ -10256,21 +12683,6 @@ public:
 	const LDKCVec_C2Tuple_usizeTransactionZZ* operator &() const { return &self; }
 	const LDKCVec_C2Tuple_usizeTransactionZZ* operator ->() const { return &self; }
 };
-class CResult_TxRemoveInputDecodeErrorZ {
-private:
-	LDKCResult_TxRemoveInputDecodeErrorZ self;
-public:
-	CResult_TxRemoveInputDecodeErrorZ(const CResult_TxRemoveInputDecodeErrorZ&) = delete;
-	CResult_TxRemoveInputDecodeErrorZ(CResult_TxRemoveInputDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxRemoveInputDecodeErrorZ)); }
-	CResult_TxRemoveInputDecodeErrorZ(LDKCResult_TxRemoveInputDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxRemoveInputDecodeErrorZ)); }
-	operator LDKCResult_TxRemoveInputDecodeErrorZ() && { LDKCResult_TxRemoveInputDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxRemoveInputDecodeErrorZ)); return res; }
-	~CResult_TxRemoveInputDecodeErrorZ() { CResult_TxRemoveInputDecodeErrorZ_free(self); }
-	CResult_TxRemoveInputDecodeErrorZ& operator=(CResult_TxRemoveInputDecodeErrorZ&& o) { CResult_TxRemoveInputDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxRemoveInputDecodeErrorZ)); return *this; }
-	LDKCResult_TxRemoveInputDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_TxRemoveInputDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_TxRemoveInputDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_TxRemoveInputDecodeErrorZ* operator ->() const { return &self; }
-};
 class CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ {
 private:
 	LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ self;
@@ -10286,20 +12698,20 @@ public:
 	const LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ* operator &() const { return &self; }
 	const LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ* operator ->() const { return &self; }
 };
-class CResult_OffersMessageDecodeErrorZ {
+class CResult_Bolt12InvoiceDecodeErrorZ {
 private:
-	LDKCResult_OffersMessageDecodeErrorZ self;
+	LDKCResult_Bolt12InvoiceDecodeErrorZ self;
 public:
-	CResult_OffersMessageDecodeErrorZ(const CResult_OffersMessageDecodeErrorZ&) = delete;
-	CResult_OffersMessageDecodeErrorZ(CResult_OffersMessageDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OffersMessageDecodeErrorZ)); }
-	CResult_OffersMessageDecodeErrorZ(LDKCResult_OffersMessageDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OffersMessageDecodeErrorZ)); }
-	operator LDKCResult_OffersMessageDecodeErrorZ() && { LDKCResult_OffersMessageDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OffersMessageDecodeErrorZ)); return res; }
-	~CResult_OffersMessageDecodeErrorZ() { CResult_OffersMessageDecodeErrorZ_free(self); }
-	CResult_OffersMessageDecodeErrorZ& operator=(CResult_OffersMessageDecodeErrorZ&& o) { CResult_OffersMessageDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OffersMessageDecodeErrorZ)); return *this; }
-	LDKCResult_OffersMessageDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_OffersMessageDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_OffersMessageDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_OffersMessageDecodeErrorZ* operator ->() const { return &self; }
+	CResult_Bolt12InvoiceDecodeErrorZ(const CResult_Bolt12InvoiceDecodeErrorZ&) = delete;
+	CResult_Bolt12InvoiceDecodeErrorZ(CResult_Bolt12InvoiceDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt12InvoiceDecodeErrorZ)); }
+	CResult_Bolt12InvoiceDecodeErrorZ(LDKCResult_Bolt12InvoiceDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt12InvoiceDecodeErrorZ)); }
+	operator LDKCResult_Bolt12InvoiceDecodeErrorZ() && { LDKCResult_Bolt12InvoiceDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt12InvoiceDecodeErrorZ)); return res; }
+	~CResult_Bolt12InvoiceDecodeErrorZ() { CResult_Bolt12InvoiceDecodeErrorZ_free(self); }
+	CResult_Bolt12InvoiceDecodeErrorZ& operator=(CResult_Bolt12InvoiceDecodeErrorZ&& o) { CResult_Bolt12InvoiceDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt12InvoiceDecodeErrorZ)); return *this; }
+	LDKCResult_Bolt12InvoiceDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_Bolt12InvoiceDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_Bolt12InvoiceDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_Bolt12InvoiceDecodeErrorZ* operator ->() const { return &self; }
 };
 class C2Tuple_u64u64Z {
 private:
@@ -10310,26 +12722,56 @@ public:
 	C2Tuple_u64u64Z(LDKC2Tuple_u64u64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_u64u64Z)); }
 	operator LDKC2Tuple_u64u64Z() && { LDKC2Tuple_u64u64Z res = self; memset(&self, 0, sizeof(LDKC2Tuple_u64u64Z)); return res; }
 	~C2Tuple_u64u64Z() { C2Tuple_u64u64Z_free(self); }
-	C2Tuple_u64u64Z& operator=(C2Tuple_u64u64Z&& o) { C2Tuple_u64u64Z_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_u64u64Z)); return *this; }
-	LDKC2Tuple_u64u64Z* operator &() { return &self; }
-	LDKC2Tuple_u64u64Z* operator ->() { return &self; }
-	const LDKC2Tuple_u64u64Z* operator &() const { return &self; }
-	const LDKC2Tuple_u64u64Z* operator ->() const { return &self; }
-};
-class CResult_CounterpartyChannelTransactionParametersDecodeErrorZ {
-private:
-	LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ self;
-public:
-	CResult_CounterpartyChannelTransactionParametersDecodeErrorZ(const CResult_CounterpartyChannelTransactionParametersDecodeErrorZ&) = delete;
-	CResult_CounterpartyChannelTransactionParametersDecodeErrorZ(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); }
-	CResult_CounterpartyChannelTransactionParametersDecodeErrorZ(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); }
-	operator LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ() && { LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); return res; }
-	~CResult_CounterpartyChannelTransactionParametersDecodeErrorZ() { CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(self); }
-	CResult_CounterpartyChannelTransactionParametersDecodeErrorZ& operator=(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ&& o) { CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); return *this; }
-	LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator ->() const { return &self; }
+	C2Tuple_u64u64Z& operator=(C2Tuple_u64u64Z&& o) { C2Tuple_u64u64Z_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_u64u64Z)); return *this; }
+	LDKC2Tuple_u64u64Z* operator &() { return &self; }
+	LDKC2Tuple_u64u64Z* operator ->() { return &self; }
+	const LDKC2Tuple_u64u64Z* operator &() const { return &self; }
+	const LDKC2Tuple_u64u64Z* operator ->() const { return &self; }
+};
+class COption_NodeAnnouncementInfoZ {
+private:
+	LDKCOption_NodeAnnouncementInfoZ self;
+public:
+	COption_NodeAnnouncementInfoZ(const COption_NodeAnnouncementInfoZ&) = delete;
+	COption_NodeAnnouncementInfoZ(COption_NodeAnnouncementInfoZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_NodeAnnouncementInfoZ)); }
+	COption_NodeAnnouncementInfoZ(LDKCOption_NodeAnnouncementInfoZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_NodeAnnouncementInfoZ)); }
+	operator LDKCOption_NodeAnnouncementInfoZ() && { LDKCOption_NodeAnnouncementInfoZ res = self; memset(&self, 0, sizeof(LDKCOption_NodeAnnouncementInfoZ)); return res; }
+	~COption_NodeAnnouncementInfoZ() { COption_NodeAnnouncementInfoZ_free(self); }
+	COption_NodeAnnouncementInfoZ& operator=(COption_NodeAnnouncementInfoZ&& o) { COption_NodeAnnouncementInfoZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_NodeAnnouncementInfoZ)); return *this; }
+	LDKCOption_NodeAnnouncementInfoZ* operator &() { return &self; }
+	LDKCOption_NodeAnnouncementInfoZ* operator ->() { return &self; }
+	const LDKCOption_NodeAnnouncementInfoZ* operator &() const { return &self; }
+	const LDKCOption_NodeAnnouncementInfoZ* operator ->() const { return &self; }
+};
+class CResult_PendingHTLCRoutingDecodeErrorZ {
+private:
+	LDKCResult_PendingHTLCRoutingDecodeErrorZ self;
+public:
+	CResult_PendingHTLCRoutingDecodeErrorZ(const CResult_PendingHTLCRoutingDecodeErrorZ&) = delete;
+	CResult_PendingHTLCRoutingDecodeErrorZ(CResult_PendingHTLCRoutingDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PendingHTLCRoutingDecodeErrorZ)); }
+	CResult_PendingHTLCRoutingDecodeErrorZ(LDKCResult_PendingHTLCRoutingDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PendingHTLCRoutingDecodeErrorZ)); }
+	operator LDKCResult_PendingHTLCRoutingDecodeErrorZ() && { LDKCResult_PendingHTLCRoutingDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PendingHTLCRoutingDecodeErrorZ)); return res; }
+	~CResult_PendingHTLCRoutingDecodeErrorZ() { CResult_PendingHTLCRoutingDecodeErrorZ_free(self); }
+	CResult_PendingHTLCRoutingDecodeErrorZ& operator=(CResult_PendingHTLCRoutingDecodeErrorZ&& o) { CResult_PendingHTLCRoutingDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PendingHTLCRoutingDecodeErrorZ)); return *this; }
+	LDKCResult_PendingHTLCRoutingDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_PendingHTLCRoutingDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_PendingHTLCRoutingDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_PendingHTLCRoutingDecodeErrorZ* operator ->() const { return &self; }
+};
+class COption_C2Tuple_OnionMessageContentsResponseInstructionZZ {
+private:
+	LDKCOption_C2Tuple_OnionMessageContentsResponseInstructionZZ self;
+public:
+	COption_C2Tuple_OnionMessageContentsResponseInstructionZZ(const COption_C2Tuple_OnionMessageContentsResponseInstructionZZ&) = delete;
+	COption_C2Tuple_OnionMessageContentsResponseInstructionZZ(COption_C2Tuple_OnionMessageContentsResponseInstructionZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_C2Tuple_OnionMessageContentsResponseInstructionZZ)); }
+	COption_C2Tuple_OnionMessageContentsResponseInstructionZZ(LDKCOption_C2Tuple_OnionMessageContentsResponseInstructionZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_C2Tuple_OnionMessageContentsResponseInstructionZZ)); }
+	operator LDKCOption_C2Tuple_OnionMessageContentsResponseInstructionZZ() && { LDKCOption_C2Tuple_OnionMessageContentsResponseInstructionZZ res = self; memset(&self, 0, sizeof(LDKCOption_C2Tuple_OnionMessageContentsResponseInstructionZZ)); return res; }
+	~COption_C2Tuple_OnionMessageContentsResponseInstructionZZ() { COption_C2Tuple_OnionMessageContentsResponseInstructionZZ_free(self); }
+	COption_C2Tuple_OnionMessageContentsResponseInstructionZZ& operator=(COption_C2Tuple_OnionMessageContentsResponseInstructionZZ&& o) { COption_C2Tuple_OnionMessageContentsResponseInstructionZZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_C2Tuple_OnionMessageContentsResponseInstructionZZ)); return *this; }
+	LDKCOption_C2Tuple_OnionMessageContentsResponseInstructionZZ* operator &() { return &self; }
+	LDKCOption_C2Tuple_OnionMessageContentsResponseInstructionZZ* operator ->() { return &self; }
+	const LDKCOption_C2Tuple_OnionMessageContentsResponseInstructionZZ* operator &() const { return &self; }
+	const LDKCOption_C2Tuple_OnionMessageContentsResponseInstructionZZ* operator ->() const { return &self; }
 };
 class CResult_RecipientOnionFieldsDecodeErrorZ {
 private:
@@ -10361,6 +12803,51 @@ public:
 	const LDKC2Tuple_u32TxOutZ* operator &() const { return &self; }
 	const LDKC2Tuple_u32TxOutZ* operator ->() const { return &self; }
 };
+class CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ {
+private:
+	LDKCResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ self;
+public:
+	CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ(const CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ&) = delete;
+	CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ(CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ)); }
+	CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ(LDKCResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ)); }
+	operator LDKCResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ() && { LDKCResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ)); return res; }
+	~CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ() { CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ_free(self); }
+	CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ& operator=(CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ&& o) { CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ)); return *this; }
+	LDKCResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ* operator &() { return &self; }
+	LDKCResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ* operator ->() { return &self; }
+	const LDKCResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ* operator &() const { return &self; }
+	const LDKCResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ* operator ->() const { return &self; }
+};
+class CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ {
+private:
+	LDKCResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ self;
+public:
+	CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ(const CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ&) = delete;
+	CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ(CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ)); }
+	CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ(LDKCResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ)); }
+	operator LDKCResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ() && { LDKCResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ)); return res; }
+	~CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ() { CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ_free(self); }
+	CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ& operator=(CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ&& o) { CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ)); return *this; }
+	LDKCResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ* operator &() { return &self; }
+	LDKCResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ* operator ->() { return &self; }
+	const LDKCResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ* operator &() const { return &self; }
+	const LDKCResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ* 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_UtxoZ {
 private:
 	LDKCVec_UtxoZ self;
@@ -10376,6 +12863,21 @@ public:
 	const LDKCVec_UtxoZ* operator &() const { return &self; }
 	const LDKCVec_UtxoZ* operator ->() const { return &self; }
 };
+class CResult_CounterpartyChannelTransactionParametersDecodeErrorZ {
+private:
+	LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ self;
+public:
+	CResult_CounterpartyChannelTransactionParametersDecodeErrorZ(const CResult_CounterpartyChannelTransactionParametersDecodeErrorZ&) = delete;
+	CResult_CounterpartyChannelTransactionParametersDecodeErrorZ(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); }
+	CResult_CounterpartyChannelTransactionParametersDecodeErrorZ(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); }
+	operator LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ() && { LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); return res; }
+	~CResult_CounterpartyChannelTransactionParametersDecodeErrorZ() { CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(self); }
+	CResult_CounterpartyChannelTransactionParametersDecodeErrorZ& operator=(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ&& o) { CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); return *this; }
+	LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator ->() const { return &self; }
+};
 class CResult_ChannelConfigDecodeErrorZ {
 private:
 	LDKCResult_ChannelConfigDecodeErrorZ self;
@@ -10421,6 +12923,51 @@ public:
 	const LDKCOption_i64Z* operator &() const { return &self; }
 	const LDKCOption_i64Z* operator ->() const { return &self; }
 };
+class CResult_PaymentContextDecodeErrorZ {
+private:
+	LDKCResult_PaymentContextDecodeErrorZ self;
+public:
+	CResult_PaymentContextDecodeErrorZ(const CResult_PaymentContextDecodeErrorZ&) = delete;
+	CResult_PaymentContextDecodeErrorZ(CResult_PaymentContextDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentContextDecodeErrorZ)); }
+	CResult_PaymentContextDecodeErrorZ(LDKCResult_PaymentContextDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentContextDecodeErrorZ)); }
+	operator LDKCResult_PaymentContextDecodeErrorZ() && { LDKCResult_PaymentContextDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentContextDecodeErrorZ)); return res; }
+	~CResult_PaymentContextDecodeErrorZ() { CResult_PaymentContextDecodeErrorZ_free(self); }
+	CResult_PaymentContextDecodeErrorZ& operator=(CResult_PaymentContextDecodeErrorZ&& o) { CResult_PaymentContextDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentContextDecodeErrorZ)); return *this; }
+	LDKCResult_PaymentContextDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_PaymentContextDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_PaymentContextDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_PaymentContextDecodeErrorZ* 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 CVec_C2Tuple_OutPointCVec_u64ZZZ {
+private:
+	LDKCVec_C2Tuple_OutPointCVec_u64ZZZ self;
+public:
+	CVec_C2Tuple_OutPointCVec_u64ZZZ(const CVec_C2Tuple_OutPointCVec_u64ZZZ&) = delete;
+	CVec_C2Tuple_OutPointCVec_u64ZZZ(CVec_C2Tuple_OutPointCVec_u64ZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_OutPointCVec_u64ZZZ)); }
+	CVec_C2Tuple_OutPointCVec_u64ZZZ(LDKCVec_C2Tuple_OutPointCVec_u64ZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_OutPointCVec_u64ZZZ)); }
+	operator LDKCVec_C2Tuple_OutPointCVec_u64ZZZ() && { LDKCVec_C2Tuple_OutPointCVec_u64ZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_OutPointCVec_u64ZZZ)); return res; }
+	~CVec_C2Tuple_OutPointCVec_u64ZZZ() { CVec_C2Tuple_OutPointCVec_u64ZZZ_free(self); }
+	CVec_C2Tuple_OutPointCVec_u64ZZZ& operator=(CVec_C2Tuple_OutPointCVec_u64ZZZ&& o) { CVec_C2Tuple_OutPointCVec_u64ZZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_OutPointCVec_u64ZZZ)); return *this; }
+	LDKCVec_C2Tuple_OutPointCVec_u64ZZZ* operator &() { return &self; }
+	LDKCVec_C2Tuple_OutPointCVec_u64ZZZ* operator ->() { return &self; }
+	const LDKCVec_C2Tuple_OutPointCVec_u64ZZZ* operator &() const { return &self; }
+	const LDKCVec_C2Tuple_OutPointCVec_u64ZZZ* operator ->() const { return &self; }
+};
 class C2Tuple_ThirtyTwoBytesChannelManagerZ {
 private:
 	LDKC2Tuple_ThirtyTwoBytesChannelManagerZ self;
@@ -10556,21 +13103,6 @@ public:
 	const LDKCResult_TxOutUtxoLookupErrorZ* operator &() const { return &self; }
 	const LDKCResult_TxOutUtxoLookupErrorZ* operator ->() const { return &self; }
 };
-class CResult_BlindedPathNoneZ {
-private:
-	LDKCResult_BlindedPathNoneZ self;
-public:
-	CResult_BlindedPathNoneZ(const CResult_BlindedPathNoneZ&) = delete;
-	CResult_BlindedPathNoneZ(CResult_BlindedPathNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedPathNoneZ)); }
-	CResult_BlindedPathNoneZ(LDKCResult_BlindedPathNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedPathNoneZ)); }
-	operator LDKCResult_BlindedPathNoneZ() && { LDKCResult_BlindedPathNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedPathNoneZ)); return res; }
-	~CResult_BlindedPathNoneZ() { CResult_BlindedPathNoneZ_free(self); }
-	CResult_BlindedPathNoneZ& operator=(CResult_BlindedPathNoneZ&& o) { CResult_BlindedPathNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedPathNoneZ)); return *this; }
-	LDKCResult_BlindedPathNoneZ* operator &() { return &self; }
-	LDKCResult_BlindedPathNoneZ* operator ->() { return &self; }
-	const LDKCResult_BlindedPathNoneZ* operator &() const { return &self; }
-	const LDKCResult_BlindedPathNoneZ* operator ->() const { return &self; }
-};
 class COption_usizeZ {
 private:
 	LDKCOption_usizeZ self;
@@ -10586,20 +13118,35 @@ public:
 	const LDKCOption_usizeZ* operator &() const { return &self; }
 	const LDKCOption_usizeZ* operator ->() const { return &self; }
 };
-class CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ {
+class CVec_BlindedMessagePathZ {
+private:
+	LDKCVec_BlindedMessagePathZ self;
+public:
+	CVec_BlindedMessagePathZ(const CVec_BlindedMessagePathZ&) = delete;
+	CVec_BlindedMessagePathZ(CVec_BlindedMessagePathZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_BlindedMessagePathZ)); }
+	CVec_BlindedMessagePathZ(LDKCVec_BlindedMessagePathZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_BlindedMessagePathZ)); }
+	operator LDKCVec_BlindedMessagePathZ() && { LDKCVec_BlindedMessagePathZ res = self; memset(&self, 0, sizeof(LDKCVec_BlindedMessagePathZ)); return res; }
+	~CVec_BlindedMessagePathZ() { CVec_BlindedMessagePathZ_free(self); }
+	CVec_BlindedMessagePathZ& operator=(CVec_BlindedMessagePathZ&& o) { CVec_BlindedMessagePathZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_BlindedMessagePathZ)); return *this; }
+	LDKCVec_BlindedMessagePathZ* operator &() { return &self; }
+	LDKCVec_BlindedMessagePathZ* operator ->() { return &self; }
+	const LDKCVec_BlindedMessagePathZ* operator &() const { return &self; }
+	const LDKCVec_BlindedMessagePathZ* operator ->() const { return &self; }
+};
+class CResult_OffersContextDecodeErrorZ {
 private:
-	LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ self;
+	LDKCResult_OffersContextDecodeErrorZ self;
 public:
-	CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ(const CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ&) = delete;
-	CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ(CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ)); }
-	CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ(LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ)); }
-	operator LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ() && { LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ res = self; memset(&self, 0, sizeof(LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ)); return res; }
-	~CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ() { CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(self); }
-	CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ& operator=(CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ&& o) { CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ)); return *this; }
-	LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ* operator &() { return &self; }
-	LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ* operator ->() { return &self; }
-	const LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ* operator &() const { return &self; }
-	const LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ* operator ->() const { return &self; }
+	CResult_OffersContextDecodeErrorZ(const CResult_OffersContextDecodeErrorZ&) = delete;
+	CResult_OffersContextDecodeErrorZ(CResult_OffersContextDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OffersContextDecodeErrorZ)); }
+	CResult_OffersContextDecodeErrorZ(LDKCResult_OffersContextDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OffersContextDecodeErrorZ)); }
+	operator LDKCResult_OffersContextDecodeErrorZ() && { LDKCResult_OffersContextDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OffersContextDecodeErrorZ)); return res; }
+	~CResult_OffersContextDecodeErrorZ() { CResult_OffersContextDecodeErrorZ_free(self); }
+	CResult_OffersContextDecodeErrorZ& operator=(CResult_OffersContextDecodeErrorZ&& o) { CResult_OffersContextDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OffersContextDecodeErrorZ)); return *this; }
+	LDKCResult_OffersContextDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_OffersContextDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_OffersContextDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_OffersContextDecodeErrorZ* operator ->() const { return &self; }
 };
 class CResult_NoneNoneZ {
 private:
@@ -10691,6 +13238,21 @@ public:
 	const LDKCOption_ClosureReasonZ* operator &() const { return &self; }
 	const LDKCOption_ClosureReasonZ* operator ->() const { return &self; }
 };
+class CVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ {
+private:
+	LDKCVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ self;
+public:
+	CVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ(const CVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ&) = delete;
+	CVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ(CVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ)); }
+	CVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ(LDKCVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ)); }
+	operator LDKCVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ() && { LDKCVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ)); return res; }
+	~CVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ() { CVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ_free(self); }
+	CVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ& operator=(CVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ&& o) { CVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ)); return *this; }
+	LDKCVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ* operator &() { return &self; }
+	LDKCVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ* operator ->() { return &self; }
+	const LDKCVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ* operator &() const { return &self; }
+	const LDKCVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ* operator ->() const { return &self; }
+};
 class CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ {
 private:
 	LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ self;
@@ -10721,6 +13283,51 @@ public:
 	const LDKCResult_TransactionU16LenLimitedDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_TransactionU16LenLimitedDecodeErrorZ* operator ->() const { return &self; }
 };
+class CResult_FundingInfoDecodeErrorZ {
+private:
+	LDKCResult_FundingInfoDecodeErrorZ self;
+public:
+	CResult_FundingInfoDecodeErrorZ(const CResult_FundingInfoDecodeErrorZ&) = delete;
+	CResult_FundingInfoDecodeErrorZ(CResult_FundingInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FundingInfoDecodeErrorZ)); }
+	CResult_FundingInfoDecodeErrorZ(LDKCResult_FundingInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FundingInfoDecodeErrorZ)); }
+	operator LDKCResult_FundingInfoDecodeErrorZ() && { LDKCResult_FundingInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FundingInfoDecodeErrorZ)); return res; }
+	~CResult_FundingInfoDecodeErrorZ() { CResult_FundingInfoDecodeErrorZ_free(self); }
+	CResult_FundingInfoDecodeErrorZ& operator=(CResult_FundingInfoDecodeErrorZ&& o) { CResult_FundingInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FundingInfoDecodeErrorZ)); return *this; }
+	LDKCResult_FundingInfoDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_FundingInfoDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_FundingInfoDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_FundingInfoDecodeErrorZ* operator ->() const { return &self; }
+};
+class COption_AmountZ {
+private:
+	LDKCOption_AmountZ self;
+public:
+	COption_AmountZ(const COption_AmountZ&) = delete;
+	COption_AmountZ(COption_AmountZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_AmountZ)); }
+	COption_AmountZ(LDKCOption_AmountZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_AmountZ)); }
+	operator LDKCOption_AmountZ() && { LDKCOption_AmountZ res = self; memset(&self, 0, sizeof(LDKCOption_AmountZ)); return res; }
+	~COption_AmountZ() { COption_AmountZ_free(self); }
+	COption_AmountZ& operator=(COption_AmountZ&& o) { COption_AmountZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_AmountZ)); return *this; }
+	LDKCOption_AmountZ* operator &() { return &self; }
+	LDKCOption_AmountZ* operator ->() { return &self; }
+	const LDKCOption_AmountZ* operator &() const { return &self; }
+	const LDKCOption_AmountZ* operator ->() const { return &self; }
+};
+class COption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ {
+private:
+	LDKCOption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ self;
+public:
+	COption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ(const COption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ&) = delete;
+	COption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ(COption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ)); }
+	COption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ(LDKCOption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ)); }
+	operator LDKCOption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ() && { LDKCOption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ res = self; memset(&self, 0, sizeof(LDKCOption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ)); return res; }
+	~COption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ() { COption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ_free(self); }
+	COption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ& operator=(COption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ&& o) { COption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ)); return *this; }
+	LDKCOption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ* operator &() { return &self; }
+	LDKCOption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ* operator ->() { return &self; }
+	const LDKCOption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ* operator &() const { return &self; }
+	const LDKCOption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ* operator ->() const { return &self; }
+};
 class CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ {
 private:
 	LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ self;
@@ -10736,21 +13343,6 @@ public:
 	const LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ* operator &() const { return &self; }
 	const LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ* 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 CResult_OpenChannelV2DecodeErrorZ {
 private:
 	LDKCResult_OpenChannelV2DecodeErrorZ self;
@@ -10766,6 +13358,21 @@ public:
 	const LDKCResult_OpenChannelV2DecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_OpenChannelV2DecodeErrorZ* operator ->() const { return &self; }
 };
+class CResult_BestBlockDecodeErrorZ {
+private:
+	LDKCResult_BestBlockDecodeErrorZ self;
+public:
+	CResult_BestBlockDecodeErrorZ(const CResult_BestBlockDecodeErrorZ&) = delete;
+	CResult_BestBlockDecodeErrorZ(CResult_BestBlockDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BestBlockDecodeErrorZ)); }
+	CResult_BestBlockDecodeErrorZ(LDKCResult_BestBlockDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BestBlockDecodeErrorZ)); }
+	operator LDKCResult_BestBlockDecodeErrorZ() && { LDKCResult_BestBlockDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BestBlockDecodeErrorZ)); return res; }
+	~CResult_BestBlockDecodeErrorZ() { CResult_BestBlockDecodeErrorZ_free(self); }
+	CResult_BestBlockDecodeErrorZ& operator=(CResult_BestBlockDecodeErrorZ&& o) { CResult_BestBlockDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BestBlockDecodeErrorZ)); return *this; }
+	LDKCResult_BestBlockDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_BestBlockDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_BestBlockDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_BestBlockDecodeErrorZ* operator ->() const { return &self; }
+};
 class CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ {
 private:
 	LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ self;
@@ -10781,20 +13388,50 @@ public:
 	const LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ* operator &() const { return &self; }
 	const LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ* operator ->() const { return &self; }
 };
-class C2Tuple_PublicKeyOnionMessageZ {
+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 CResult_OutputSpendStatusDecodeErrorZ {
+private:
+	LDKCResult_OutputSpendStatusDecodeErrorZ self;
+public:
+	CResult_OutputSpendStatusDecodeErrorZ(const CResult_OutputSpendStatusDecodeErrorZ&) = delete;
+	CResult_OutputSpendStatusDecodeErrorZ(CResult_OutputSpendStatusDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OutputSpendStatusDecodeErrorZ)); }
+	CResult_OutputSpendStatusDecodeErrorZ(LDKCResult_OutputSpendStatusDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OutputSpendStatusDecodeErrorZ)); }
+	operator LDKCResult_OutputSpendStatusDecodeErrorZ() && { LDKCResult_OutputSpendStatusDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OutputSpendStatusDecodeErrorZ)); return res; }
+	~CResult_OutputSpendStatusDecodeErrorZ() { CResult_OutputSpendStatusDecodeErrorZ_free(self); }
+	CResult_OutputSpendStatusDecodeErrorZ& operator=(CResult_OutputSpendStatusDecodeErrorZ&& o) { CResult_OutputSpendStatusDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OutputSpendStatusDecodeErrorZ)); return *this; }
+	LDKCResult_OutputSpendStatusDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_OutputSpendStatusDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_OutputSpendStatusDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_OutputSpendStatusDecodeErrorZ* operator ->() const { return &self; }
+};
+class C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ {
 private:
-	LDKC2Tuple_PublicKeyOnionMessageZ self;
+	LDKC4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ self;
 public:
-	C2Tuple_PublicKeyOnionMessageZ(const C2Tuple_PublicKeyOnionMessageZ&) = delete;
-	C2Tuple_PublicKeyOnionMessageZ(C2Tuple_PublicKeyOnionMessageZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_PublicKeyOnionMessageZ)); }
-	C2Tuple_PublicKeyOnionMessageZ(LDKC2Tuple_PublicKeyOnionMessageZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_PublicKeyOnionMessageZ)); }
-	operator LDKC2Tuple_PublicKeyOnionMessageZ() && { LDKC2Tuple_PublicKeyOnionMessageZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_PublicKeyOnionMessageZ)); return res; }
-	~C2Tuple_PublicKeyOnionMessageZ() { C2Tuple_PublicKeyOnionMessageZ_free(self); }
-	C2Tuple_PublicKeyOnionMessageZ& operator=(C2Tuple_PublicKeyOnionMessageZ&& o) { C2Tuple_PublicKeyOnionMessageZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_PublicKeyOnionMessageZ)); return *this; }
-	LDKC2Tuple_PublicKeyOnionMessageZ* operator &() { return &self; }
-	LDKC2Tuple_PublicKeyOnionMessageZ* operator ->() { return &self; }
-	const LDKC2Tuple_PublicKeyOnionMessageZ* operator &() const { return &self; }
-	const LDKC2Tuple_PublicKeyOnionMessageZ* operator ->() const { return &self; }
+	C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ(const C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ&) = delete;
+	C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ(C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ&& o) : self(o.self) { memset(&o, 0, sizeof(C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ)); }
+	C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ(LDKC4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ)); }
+	operator LDKC4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ() && { LDKC4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ res = self; memset(&self, 0, sizeof(LDKC4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ)); return res; }
+	~C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ() { C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ_free(self); }
+	C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ& operator=(C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ&& o) { C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ_free(self); self = o.self; memset(&o, 0, sizeof(C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ)); return *this; }
+	LDKC4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ* operator &() { return &self; }
+	LDKC4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ* operator ->() { return &self; }
+	const LDKC4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ* operator &() const { return &self; }
+	const LDKC4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ* operator ->() const { return &self; }
 };
 class CResult_RouteDecodeErrorZ {
 private:
@@ -10811,6 +13448,21 @@ public:
 	const LDKCResult_RouteDecodeErrorZ* operator &() const { return &self; }
 	const LDKCResult_RouteDecodeErrorZ* operator ->() const { return &self; }
 };
+class CResult_BlindedFailureDecodeErrorZ {
+private:
+	LDKCResult_BlindedFailureDecodeErrorZ self;
+public:
+	CResult_BlindedFailureDecodeErrorZ(const CResult_BlindedFailureDecodeErrorZ&) = delete;
+	CResult_BlindedFailureDecodeErrorZ(CResult_BlindedFailureDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedFailureDecodeErrorZ)); }
+	CResult_BlindedFailureDecodeErrorZ(LDKCResult_BlindedFailureDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedFailureDecodeErrorZ)); }
+	operator LDKCResult_BlindedFailureDecodeErrorZ() && { LDKCResult_BlindedFailureDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedFailureDecodeErrorZ)); return res; }
+	~CResult_BlindedFailureDecodeErrorZ() { CResult_BlindedFailureDecodeErrorZ_free(self); }
+	CResult_BlindedFailureDecodeErrorZ& operator=(CResult_BlindedFailureDecodeErrorZ&& o) { CResult_BlindedFailureDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedFailureDecodeErrorZ)); return *this; }
+	LDKCResult_BlindedFailureDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_BlindedFailureDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_BlindedFailureDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_BlindedFailureDecodeErrorZ* operator ->() const { return &self; }
+};
 class CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ {
 private:
 	LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ self;
@@ -10841,20 +13493,20 @@ public:
 	const LDKCOption_NoneZ* operator &() const { return &self; }
 	const LDKCOption_NoneZ* operator ->() const { return &self; }
 };
-class CResult_TxAddOutputDecodeErrorZ {
+class CResult_SpliceLockedDecodeErrorZ {
 private:
-	LDKCResult_TxAddOutputDecodeErrorZ self;
+	LDKCResult_SpliceLockedDecodeErrorZ self;
 public:
-	CResult_TxAddOutputDecodeErrorZ(const CResult_TxAddOutputDecodeErrorZ&) = delete;
-	CResult_TxAddOutputDecodeErrorZ(CResult_TxAddOutputDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxAddOutputDecodeErrorZ)); }
-	CResult_TxAddOutputDecodeErrorZ(LDKCResult_TxAddOutputDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxAddOutputDecodeErrorZ)); }
-	operator LDKCResult_TxAddOutputDecodeErrorZ() && { LDKCResult_TxAddOutputDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxAddOutputDecodeErrorZ)); return res; }
-	~CResult_TxAddOutputDecodeErrorZ() { CResult_TxAddOutputDecodeErrorZ_free(self); }
-	CResult_TxAddOutputDecodeErrorZ& operator=(CResult_TxAddOutputDecodeErrorZ&& o) { CResult_TxAddOutputDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxAddOutputDecodeErrorZ)); return *this; }
-	LDKCResult_TxAddOutputDecodeErrorZ* operator &() { return &self; }
-	LDKCResult_TxAddOutputDecodeErrorZ* operator ->() { return &self; }
-	const LDKCResult_TxAddOutputDecodeErrorZ* operator &() const { return &self; }
-	const LDKCResult_TxAddOutputDecodeErrorZ* operator ->() const { return &self; }
+	CResult_SpliceLockedDecodeErrorZ(const CResult_SpliceLockedDecodeErrorZ&) = delete;
+	CResult_SpliceLockedDecodeErrorZ(CResult_SpliceLockedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SpliceLockedDecodeErrorZ)); }
+	CResult_SpliceLockedDecodeErrorZ(LDKCResult_SpliceLockedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SpliceLockedDecodeErrorZ)); }
+	operator LDKCResult_SpliceLockedDecodeErrorZ() && { LDKCResult_SpliceLockedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SpliceLockedDecodeErrorZ)); return res; }
+	~CResult_SpliceLockedDecodeErrorZ() { CResult_SpliceLockedDecodeErrorZ_free(self); }
+	CResult_SpliceLockedDecodeErrorZ& operator=(CResult_SpliceLockedDecodeErrorZ&& o) { CResult_SpliceLockedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SpliceLockedDecodeErrorZ)); return *this; }
+	LDKCResult_SpliceLockedDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_SpliceLockedDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_SpliceLockedDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_SpliceLockedDecodeErrorZ* operator ->() const { return &self; }
 };
 class COption_CVec_u8ZZ {
 private:
@@ -10871,65 +13523,93 @@ public:
 	const LDKCOption_CVec_u8ZZ* operator &() const { return &self; }
 	const LDKCOption_CVec_u8ZZ* operator ->() const { return &self; }
 };
+class COption_QuantityZ {
+private:
+	LDKCOption_QuantityZ self;
+public:
+	COption_QuantityZ(const COption_QuantityZ&) = delete;
+	COption_QuantityZ(COption_QuantityZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_QuantityZ)); }
+	COption_QuantityZ(LDKCOption_QuantityZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_QuantityZ)); }
+	operator LDKCOption_QuantityZ() && { LDKCOption_QuantityZ res = self; memset(&self, 0, sizeof(LDKCOption_QuantityZ)); return res; }
+	~COption_QuantityZ() { COption_QuantityZ_free(self); }
+	COption_QuantityZ& operator=(COption_QuantityZ&& o) { COption_QuantityZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_QuantityZ)); return *this; }
+	LDKCOption_QuantityZ* operator &() { return &self; }
+	LDKCOption_QuantityZ* operator ->() { return &self; }
+	const LDKCOption_QuantityZ* operator &() const { return &self; }
+	const LDKCOption_QuantityZ* operator ->() const { return &self; }
+};
+class CResult_TxAddOutputDecodeErrorZ {
+private:
+	LDKCResult_TxAddOutputDecodeErrorZ self;
+public:
+	CResult_TxAddOutputDecodeErrorZ(const CResult_TxAddOutputDecodeErrorZ&) = delete;
+	CResult_TxAddOutputDecodeErrorZ(CResult_TxAddOutputDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxAddOutputDecodeErrorZ)); }
+	CResult_TxAddOutputDecodeErrorZ(LDKCResult_TxAddOutputDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxAddOutputDecodeErrorZ)); }
+	operator LDKCResult_TxAddOutputDecodeErrorZ() && { LDKCResult_TxAddOutputDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxAddOutputDecodeErrorZ)); return res; }
+	~CResult_TxAddOutputDecodeErrorZ() { CResult_TxAddOutputDecodeErrorZ_free(self); }
+	CResult_TxAddOutputDecodeErrorZ& operator=(CResult_TxAddOutputDecodeErrorZ&& o) { CResult_TxAddOutputDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxAddOutputDecodeErrorZ)); return *this; }
+	LDKCResult_TxAddOutputDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_TxAddOutputDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_TxAddOutputDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_TxAddOutputDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_HtlcBasepointDecodeErrorZ {
+private:
+	LDKCResult_HtlcBasepointDecodeErrorZ self;
+public:
+	CResult_HtlcBasepointDecodeErrorZ(const CResult_HtlcBasepointDecodeErrorZ&) = delete;
+	CResult_HtlcBasepointDecodeErrorZ(CResult_HtlcBasepointDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HtlcBasepointDecodeErrorZ)); }
+	CResult_HtlcBasepointDecodeErrorZ(LDKCResult_HtlcBasepointDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HtlcBasepointDecodeErrorZ)); }
+	operator LDKCResult_HtlcBasepointDecodeErrorZ() && { LDKCResult_HtlcBasepointDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HtlcBasepointDecodeErrorZ)); return res; }
+	~CResult_HtlcBasepointDecodeErrorZ() { CResult_HtlcBasepointDecodeErrorZ_free(self); }
+	CResult_HtlcBasepointDecodeErrorZ& operator=(CResult_HtlcBasepointDecodeErrorZ&& o) { CResult_HtlcBasepointDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HtlcBasepointDecodeErrorZ)); return *this; }
+	LDKCResult_HtlcBasepointDecodeErrorZ* operator &() { return &self; }
+	LDKCResult_HtlcBasepointDecodeErrorZ* operator ->() { return &self; }
+	const LDKCResult_HtlcBasepointDecodeErrorZ* operator &() const { return &self; }
+	const LDKCResult_HtlcBasepointDecodeErrorZ* operator ->() const { return &self; }
+};
+class C2Tuple_OutPointChannelIdZ {
+private:
+	LDKC2Tuple_OutPointChannelIdZ self;
+public:
+	C2Tuple_OutPointChannelIdZ(const C2Tuple_OutPointChannelIdZ&) = delete;
+	C2Tuple_OutPointChannelIdZ(C2Tuple_OutPointChannelIdZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_OutPointChannelIdZ)); }
+	C2Tuple_OutPointChannelIdZ(LDKC2Tuple_OutPointChannelIdZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_OutPointChannelIdZ)); }
+	operator LDKC2Tuple_OutPointChannelIdZ() && { LDKC2Tuple_OutPointChannelIdZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_OutPointChannelIdZ)); return res; }
+	~C2Tuple_OutPointChannelIdZ() { C2Tuple_OutPointChannelIdZ_free(self); }
+	C2Tuple_OutPointChannelIdZ& operator=(C2Tuple_OutPointChannelIdZ&& o) { C2Tuple_OutPointChannelIdZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_OutPointChannelIdZ)); return *this; }
+	LDKC2Tuple_OutPointChannelIdZ* operator &() { return &self; }
+	LDKC2Tuple_OutPointChannelIdZ* operator ->() { return &self; }
+	const LDKC2Tuple_OutPointChannelIdZ* operator &() const { return &self; }
+	const LDKC2Tuple_OutPointChannelIdZ* operator ->() const { return &self; }
+};
 
-inline LDKPublicKey ChannelSigner::get_per_commitment_point(uint64_t idx) {
-	LDKPublicKey ret = (self.get_per_commitment_point)(self.this_arg, idx);
+inline LDK::CResult_SchnorrSignatureNoneZ SignBolt12InvoiceFn::sign_invoice(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR message) {
+	LDK::CResult_SchnorrSignatureNoneZ ret = (self.sign_invoice)(self.this_arg, message);
 	return ret;
 }
-inline LDKThirtyTwoBytes ChannelSigner::release_commitment_secret(uint64_t idx) {
-	LDKThirtyTwoBytes ret = (self.release_commitment_secret)(self.this_arg, idx);
+inline LDK::CResult_PublicKeyNoneZ ChannelSigner::get_per_commitment_point(uint64_t idx) {
+	LDK::CResult_PublicKeyNoneZ ret = (self.get_per_commitment_point)(self.this_arg, idx);
 	return ret;
 }
-inline LDK::CResult_NoneNoneZ ChannelSigner::validate_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_ThirtyTwoBytesZ preimages) {
-	LDK::CResult_NoneNoneZ ret = (self.validate_holder_commitment)(self.this_arg, holder_tx, preimages);
-	return ret;
-}
-inline LDKThirtyTwoBytes ChannelSigner::channel_keys_id() {
-	LDKThirtyTwoBytes ret = (self.channel_keys_id)(self.this_arg);
+inline LDK::CResult__u832NoneZ ChannelSigner::release_commitment_secret(uint64_t idx) {
+	LDK::CResult__u832NoneZ ret = (self.release_commitment_secret)(self.this_arg, idx);
 	return ret;
 }
-inline void ChannelSigner::provide_channel_parameters(const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters) {
-	(self.provide_channel_parameters)(self.this_arg, channel_parameters);
-}
-inline LDK::CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ EcdsaChannelSigner::sign_counterparty_commitment(const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx, struct LDKCVec_ThirtyTwoBytesZ preimages) {
-	LDK::CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ ret = (self.sign_counterparty_commitment)(self.this_arg, commitment_tx, preimages);
+inline LDK::CResult_NoneNoneZ ChannelSigner::validate_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_ThirtyTwoBytesZ outbound_htlc_preimages) {
+	LDK::CResult_NoneNoneZ ret = (self.validate_holder_commitment)(self.this_arg, holder_tx, outbound_htlc_preimages);
 	return ret;
 }
-inline LDK::CResult_NoneNoneZ EcdsaChannelSigner::validate_counterparty_revocation(uint64_t idx, const uint8_t (*secret)[32]) {
+inline LDK::CResult_NoneNoneZ ChannelSigner::validate_counterparty_revocation(uint64_t idx, const uint8_t (*secret)[32]) {
 	LDK::CResult_NoneNoneZ ret = (self.validate_counterparty_revocation)(self.this_arg, idx, secret);
 	return ret;
 }
-inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx) {
-	LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_holder_commitment)(self.this_arg, commitment_tx);
-	return ret;
-}
-inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_justice_revoked_output(struct LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (*per_commitment_key)[32]) {
-	LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_justice_revoked_output)(self.this_arg, justice_tx, input, amount, per_commitment_key);
-	return ret;
-}
-inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_justice_revoked_htlc(struct LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (*per_commitment_key)[32], const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc) {
-	LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_justice_revoked_htlc)(self.this_arg, justice_tx, input, amount, per_commitment_key, htlc);
-	return ret;
-}
-inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_holder_htlc_transaction(struct LDKTransaction htlc_tx, uintptr_t input, const struct LDKHTLCDescriptor *NONNULL_PTR htlc_descriptor) {
-	LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_holder_htlc_transaction)(self.this_arg, htlc_tx, input, htlc_descriptor);
-	return ret;
-}
-inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_counterparty_htlc_transaction(struct LDKTransaction htlc_tx, uintptr_t input, uint64_t amount, struct LDKPublicKey per_commitment_point, const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc) {
-	LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_counterparty_htlc_transaction)(self.this_arg, htlc_tx, input, amount, per_commitment_point, htlc);
-	return ret;
-}
-inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_closing_transaction(const struct LDKClosingTransaction *NONNULL_PTR closing_tx) {
-	LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_closing_transaction)(self.this_arg, closing_tx);
-	return ret;
-}
-inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_holder_anchor_input(struct LDKTransaction anchor_tx, uintptr_t input) {
-	LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_holder_anchor_input)(self.this_arg, anchor_tx, input);
+inline LDKThirtyTwoBytes ChannelSigner::channel_keys_id() {
+	LDKThirtyTwoBytes ret = (self.channel_keys_id)(self.this_arg);
 	return ret;
 }
-inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_channel_announcement_with_funding_key(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg) {
-	LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_channel_announcement_with_funding_key)(self.this_arg, msg);
-	return ret;
+inline void ChannelSigner::provide_channel_parameters(const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters) {
+	(self.provide_channel_parameters)(self.this_arg, channel_parameters);
 }
 inline LDKThirtyTwoBytes EntropySource::get_secure_random_bytes() {
 	LDKThirtyTwoBytes ret = (self.get_secure_random_bytes)(self.this_arg);
@@ -10947,8 +13627,8 @@ inline LDK::CResult_ThirtyTwoBytesNoneZ NodeSigner::ecdh(enum LDKRecipient recip
 	LDK::CResult_ThirtyTwoBytesNoneZ ret = (self.ecdh)(self.this_arg, recipient, other_key, tweak);
 	return ret;
 }
-inline LDK::CResult_RecoverableSignatureNoneZ NodeSigner::sign_invoice(struct LDKu8slice hrp_bytes, struct LDKCVec_U5Z invoice_data, enum LDKRecipient recipient) {
-	LDK::CResult_RecoverableSignatureNoneZ ret = (self.sign_invoice)(self.this_arg, hrp_bytes, invoice_data, recipient);
+inline LDK::CResult_RecoverableSignatureNoneZ NodeSigner::sign_invoice(const struct LDKRawBolt11Invoice *NONNULL_PTR invoice, enum LDKRecipient recipient) {
+	LDK::CResult_RecoverableSignatureNoneZ ret = (self.sign_invoice)(self.this_arg, invoice, recipient);
 	return ret;
 }
 inline LDK::CResult_SchnorrSignatureNoneZ NodeSigner::sign_bolt12_invoice_request(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR invoice_request) {
@@ -10963,26 +13643,34 @@ inline LDK::CResult_ECDSASignatureNoneZ NodeSigner::sign_gossip_message(struct L
 	LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_gossip_message)(self.this_arg, msg);
 	return ret;
 }
+inline LDK::CResult_TransactionNoneZ OutputSpender::spend_spendable_outputs(struct LDKCVec_SpendableOutputDescriptorZ descriptors, struct LDKCVec_TxOutZ outputs, struct LDKCVec_u8Z change_destination_script, uint32_t feerate_sat_per_1000_weight, struct LDKCOption_u32Z locktime) {
+	LDK::CResult_TransactionNoneZ ret = (self.spend_spendable_outputs)(self.this_arg, descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight, locktime);
+	return ret;
+}
 inline LDKThirtyTwoBytes SignerProvider::generate_channel_keys_id(bool inbound, uint64_t channel_value_satoshis, struct LDKU128 user_channel_id) {
 	LDKThirtyTwoBytes ret = (self.generate_channel_keys_id)(self.this_arg, inbound, channel_value_satoshis, user_channel_id);
 	return ret;
 }
-inline LDK::WriteableEcdsaChannelSigner SignerProvider::derive_channel_signer(uint64_t channel_value_satoshis, struct LDKThirtyTwoBytes channel_keys_id) {
-	LDK::WriteableEcdsaChannelSigner ret = (self.derive_channel_signer)(self.this_arg, channel_value_satoshis, channel_keys_id);
+inline LDK::EcdsaChannelSigner SignerProvider::derive_channel_signer(uint64_t channel_value_satoshis, struct LDKThirtyTwoBytes channel_keys_id) {
+	LDK::EcdsaChannelSigner ret = (self.derive_channel_signer)(self.this_arg, channel_value_satoshis, channel_keys_id);
 	return ret;
 }
-inline LDK::CResult_WriteableEcdsaChannelSignerDecodeErrorZ SignerProvider::read_chan_signer(struct LDKu8slice reader) {
-	LDK::CResult_WriteableEcdsaChannelSignerDecodeErrorZ ret = (self.read_chan_signer)(self.this_arg, reader);
+inline LDK::CResult_EcdsaChannelSignerDecodeErrorZ SignerProvider::read_chan_signer(struct LDKu8slice reader) {
+	LDK::CResult_EcdsaChannelSignerDecodeErrorZ ret = (self.read_chan_signer)(self.this_arg, reader);
 	return ret;
 }
-inline LDK::CResult_CVec_u8ZNoneZ SignerProvider::get_destination_script() {
-	LDK::CResult_CVec_u8ZNoneZ ret = (self.get_destination_script)(self.this_arg);
+inline LDK::CResult_CVec_u8ZNoneZ SignerProvider::get_destination_script(struct LDKThirtyTwoBytes channel_keys_id) {
+	LDK::CResult_CVec_u8ZNoneZ ret = (self.get_destination_script)(self.this_arg, channel_keys_id);
 	return ret;
 }
 inline LDK::CResult_ShutdownScriptNoneZ SignerProvider::get_shutdown_scriptpubkey() {
 	LDK::CResult_ShutdownScriptNoneZ ret = (self.get_shutdown_scriptpubkey)(self.this_arg);
 	return ret;
 }
+inline LDK::CResult_CVec_u8ZNoneZ ChangeDestinationSource::get_change_destination_script() {
+	LDK::CResult_CVec_u8ZNoneZ ret = (self.get_change_destination_script)(self.this_arg);
+	return ret;
+}
 inline LDK::CResult_RouteLightningErrorZ Router::find_route(struct LDKPublicKey payer, const struct LDKRouteParameters *NONNULL_PTR route_params, struct LDKCVec_ChannelDetailsZ *first_hops, struct LDKInFlightHtlcs inflight_htlcs) {
 	LDK::CResult_RouteLightningErrorZ ret = (self.find_route)(self.this_arg, payer, route_params, first_hops, inflight_htlcs);
 	return ret;
@@ -10991,21 +13679,28 @@ inline LDK::CResult_RouteLightningErrorZ Router::find_route_with_id(struct LDKPu
 	LDK::CResult_RouteLightningErrorZ ret = (self.find_route_with_id)(self.this_arg, payer, route_params, first_hops, inflight_htlcs, _payment_hash, _payment_id);
 	return ret;
 }
-inline uint64_t ScoreLookUp::channel_penalty_msat(uint64_t short_channel_id, const struct LDKNodeId *NONNULL_PTR source, const struct LDKNodeId *NONNULL_PTR target, struct LDKChannelUsage usage, const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR score_params) {
-	uint64_t ret = (self.channel_penalty_msat)(self.this_arg, short_channel_id, source, target, usage, score_params);
+inline LDK::CResult_CVec_BlindedPaymentPathZNoneZ Router::create_blinded_payment_paths(struct LDKPublicKey recipient, struct LDKCVec_ChannelDetailsZ first_hops, struct LDKReceiveTlvs tlvs, uint64_t amount_msats) {
+	LDK::CResult_CVec_BlindedPaymentPathZNoneZ ret = (self.create_blinded_payment_paths)(self.this_arg, recipient, first_hops, tlvs, amount_msats);
 	return ret;
 }
-inline void ScoreUpdate::payment_path_failed(const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id) {
-	(self.payment_path_failed)(self.this_arg, path, short_channel_id);
+inline uint64_t ScoreLookUp::channel_penalty_msat(const struct LDKCandidateRouteHop *NONNULL_PTR candidate, struct LDKChannelUsage usage, const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR score_params) {
+	uint64_t ret = (self.channel_penalty_msat)(self.this_arg, candidate, usage, score_params);
+	return ret;
+}
+inline void ScoreUpdate::payment_path_failed(const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id, uint64_t duration_since_epoch) {
+	(self.payment_path_failed)(self.this_arg, path, short_channel_id, duration_since_epoch);
 }
-inline void ScoreUpdate::payment_path_successful(const struct LDKPath *NONNULL_PTR path) {
-	(self.payment_path_successful)(self.this_arg, path);
+inline void ScoreUpdate::payment_path_successful(const struct LDKPath *NONNULL_PTR path, uint64_t duration_since_epoch) {
+	(self.payment_path_successful)(self.this_arg, path, duration_since_epoch);
 }
-inline void ScoreUpdate::probe_failed(const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id) {
-	(self.probe_failed)(self.this_arg, path, short_channel_id);
+inline void ScoreUpdate::probe_failed(const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id, uint64_t duration_since_epoch) {
+	(self.probe_failed)(self.this_arg, path, short_channel_id, duration_since_epoch);
 }
-inline void ScoreUpdate::probe_successful(const struct LDKPath *NONNULL_PTR path) {
-	(self.probe_successful)(self.this_arg, path);
+inline void ScoreUpdate::probe_successful(const struct LDKPath *NONNULL_PTR path, uint64_t duration_since_epoch) {
+	(self.probe_successful)(self.this_arg, path, duration_since_epoch);
+}
+inline void ScoreUpdate::time_passed(uint64_t duration_since_epoch) {
+	(self.time_passed)(self.this_arg, duration_since_epoch);
 }
 inline LDK::ScoreLookUp LockableScore::read_lock() {
 	LDK::ScoreLookUp ret = (self.read_lock)(self.this_arg);
@@ -11033,8 +13728,8 @@ inline void Confirm::transaction_unconfirmed(const uint8_t (*txid)[32]) {
 inline void Confirm::best_block_updated(const uint8_t (*header)[80], uint32_t height) {
 	(self.best_block_updated)(self.this_arg, header, height);
 }
-inline LDK::CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ Confirm::get_relevant_txids() {
-	LDK::CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ ret = (self.get_relevant_txids)(self.this_arg);
+inline LDK::CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ Confirm::get_relevant_txids() {
+	LDK::CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ ret = (self.get_relevant_txids)(self.this_arg);
 	return ret;
 }
 inline LDK::CResult_ChannelMonitorUpdateStatusNoneZ Watch::watch_channel(struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor) {
@@ -11045,8 +13740,8 @@ inline LDK::ChannelMonitorUpdateStatus Watch::update_channel(struct LDKOutPoint
 	LDK::ChannelMonitorUpdateStatus ret = (self.update_channel)(self.this_arg, funding_txo, update);
 	return ret;
 }
-inline LDK::CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ Watch::release_pending_monitor_events() {
-	LDK::CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ ret = (self.release_pending_monitor_events)(self.this_arg);
+inline LDK::CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ Watch::release_pending_monitor_events() {
+	LDK::CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ ret = (self.release_pending_monitor_events)(self.this_arg);
 	return ret;
 }
 inline void Filter::register_tx(const uint8_t (*txid)[32], struct LDKu8slice script_pubkey) {
@@ -11059,8 +13754,8 @@ inline LDK::CResult_CoinSelectionNoneZ CoinSelectionSource::select_confirmed_utx
 	LDK::CResult_CoinSelectionNoneZ ret = (self.select_confirmed_utxos)(self.this_arg, claim_id, must_spend, must_pay_to, target_feerate_sat_per_1000_weight);
 	return ret;
 }
-inline LDK::CResult_TransactionNoneZ CoinSelectionSource::sign_tx(struct LDKTransaction tx) {
-	LDK::CResult_TransactionNoneZ ret = (self.sign_tx)(self.this_arg, tx);
+inline LDK::CResult_TransactionNoneZ CoinSelectionSource::sign_psbt(struct LDKCVec_u8Z psbt) {
+	LDK::CResult_TransactionNoneZ ret = (self.sign_psbt)(self.this_arg, psbt);
 	return ret;
 }
 inline LDK::CResult_CVec_UtxoZNoneZ WalletSource::list_confirmed_utxos() {
@@ -11071,8 +13766,44 @@ inline LDK::CResult_CVec_u8ZNoneZ WalletSource::get_change_script() {
 	LDK::CResult_CVec_u8ZNoneZ ret = (self.get_change_script)(self.this_arg);
 	return ret;
 }
-inline LDK::CResult_TransactionNoneZ WalletSource::sign_tx(struct LDKTransaction tx) {
-	LDK::CResult_TransactionNoneZ ret = (self.sign_tx)(self.this_arg, tx);
+inline LDK::CResult_TransactionNoneZ WalletSource::sign_psbt(struct LDKCVec_u8Z psbt) {
+	LDK::CResult_TransactionNoneZ ret = (self.sign_psbt)(self.this_arg, psbt);
+	return ret;
+}
+inline LDK::CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ EcdsaChannelSigner::sign_counterparty_commitment(const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx, struct LDKCVec_ThirtyTwoBytesZ inbound_htlc_preimages, struct LDKCVec_ThirtyTwoBytesZ outbound_htlc_preimages) {
+	LDK::CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ ret = (self.sign_counterparty_commitment)(self.this_arg, commitment_tx, inbound_htlc_preimages, outbound_htlc_preimages);
+	return ret;
+}
+inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx) {
+	LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_holder_commitment)(self.this_arg, commitment_tx);
+	return ret;
+}
+inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_justice_revoked_output(struct LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (*per_commitment_key)[32]) {
+	LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_justice_revoked_output)(self.this_arg, justice_tx, input, amount, per_commitment_key);
+	return ret;
+}
+inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_justice_revoked_htlc(struct LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (*per_commitment_key)[32], const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc) {
+	LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_justice_revoked_htlc)(self.this_arg, justice_tx, input, amount, per_commitment_key, htlc);
+	return ret;
+}
+inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_holder_htlc_transaction(struct LDKTransaction htlc_tx, uintptr_t input, const struct LDKHTLCDescriptor *NONNULL_PTR htlc_descriptor) {
+	LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_holder_htlc_transaction)(self.this_arg, htlc_tx, input, htlc_descriptor);
+	return ret;
+}
+inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_counterparty_htlc_transaction(struct LDKTransaction htlc_tx, uintptr_t input, uint64_t amount, struct LDKPublicKey per_commitment_point, const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc) {
+	LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_counterparty_htlc_transaction)(self.this_arg, htlc_tx, input, amount, per_commitment_point, htlc);
+	return ret;
+}
+inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_closing_transaction(const struct LDKClosingTransaction *NONNULL_PTR closing_tx) {
+	LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_closing_transaction)(self.this_arg, closing_tx);
+	return ret;
+}
+inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_holder_anchor_input(struct LDKTransaction anchor_tx, uintptr_t input) {
+	LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_holder_anchor_input)(self.this_arg, anchor_tx, input);
+	return ret;
+}
+inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_channel_announcement_with_funding_key(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg) {
+	LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_channel_announcement_with_funding_key)(self.this_arg, msg);
 	return ret;
 }
 inline LDK::CResult_NoneLightningErrorZ CustomMessageHandler::handle_custom_message(struct LDKType msg, struct LDKPublicKey sender_node_id) {
@@ -11083,6 +13814,13 @@ inline LDK::CVec_C2Tuple_PublicKeyTypeZZ CustomMessageHandler::get_and_clear_pen
 	LDK::CVec_C2Tuple_PublicKeyTypeZZ ret = (self.get_and_clear_pending_msg)(self.this_arg);
 	return ret;
 }
+inline void CustomMessageHandler::peer_disconnected(struct LDKPublicKey their_node_id) {
+	(self.peer_disconnected)(self.this_arg, their_node_id);
+}
+inline LDK::CResult_NoneNoneZ CustomMessageHandler::peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg, bool inbound) {
+	LDK::CResult_NoneNoneZ ret = (self.peer_connected)(self.this_arg, their_node_id, msg, inbound);
+	return ret;
+}
 inline LDK::NodeFeatures CustomMessageHandler::provided_node_features() {
 	LDK::NodeFeatures ret = (self.provided_node_features)(self.this_arg);
 	return ret;
@@ -11134,6 +13872,10 @@ inline LDK::CResult_NoneIOErrorZ Persister::persist_scorer(const struct LDKWrite
 	LDK::CResult_NoneIOErrorZ ret = (self.persist_scorer)(self.this_arg, scorer);
 	return ret;
 }
+inline LDK::CResult_SchnorrSignatureNoneZ SignInvoiceRequestFn::sign_invoice_request(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR message) {
+	LDK::CResult_SchnorrSignatureNoneZ ret = (self.sign_invoice_request)(self.this_arg, message);
+	return ret;
+}
 inline void ChannelMessageHandler::handle_open_channel(struct LDKPublicKey their_node_id, const struct LDKOpenChannel *NONNULL_PTR msg) {
 	(self.handle_open_channel)(self.this_arg, their_node_id, msg);
 }
@@ -11161,6 +13903,9 @@ inline void ChannelMessageHandler::handle_shutdown(struct LDKPublicKey their_nod
 inline void ChannelMessageHandler::handle_closing_signed(struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg) {
 	(self.handle_closing_signed)(self.this_arg, their_node_id, msg);
 }
+inline void ChannelMessageHandler::handle_stfu(struct LDKPublicKey their_node_id, const struct LDKStfu *NONNULL_PTR msg) {
+	(self.handle_stfu)(self.this_arg, their_node_id, msg);
+}
 inline void ChannelMessageHandler::handle_tx_add_input(struct LDKPublicKey their_node_id, const struct LDKTxAddInput *NONNULL_PTR msg) {
 	(self.handle_tx_add_input)(self.this_arg, their_node_id, msg);
 }
@@ -11306,6 +14051,9 @@ inline LDK::CResult_NoneNoneZ OnionMessageHandler::peer_connected(struct LDKPubl
 inline void OnionMessageHandler::peer_disconnected(struct LDKPublicKey their_node_id) {
 	(self.peer_disconnected)(self.this_arg, their_node_id);
 }
+inline void OnionMessageHandler::timer_tick_occurred() {
+	(self.timer_tick_occurred)(self.this_arg);
+}
 inline LDK::NodeFeatures OnionMessageHandler::provided_node_features() {
 	LDK::NodeFeatures ret = (self.provided_node_features)(self.this_arg);
 	return ret;
@@ -11314,18 +14062,29 @@ inline LDK::InitFeatures OnionMessageHandler::provided_init_features(struct LDKP
 	LDK::InitFeatures ret = (self.provided_init_features)(self.this_arg, their_node_id);
 	return ret;
 }
-inline void Logger::log(const struct LDKRecord *NONNULL_PTR record) {
+inline void Logger::log(struct LDKRecord record) {
 	(self.log)(self.this_arg, record);
 }
 inline void FutureCallback::call() {
 	(self.call)(self.this_arg);
 }
-inline LDK::COption_OffersMessageZ OffersMessageHandler::handle_message(struct LDKOffersMessage message) {
-	LDK::COption_OffersMessageZ ret = (self.handle_message)(self.this_arg, message);
+inline LDK::COption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ AsyncPaymentsMessageHandler::held_htlc_available(struct LDKHeldHtlcAvailable message, struct LDKResponder responder) {
+	LDK::COption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ ret = (self.held_htlc_available)(self.this_arg, message, responder);
+	return ret;
+}
+inline void AsyncPaymentsMessageHandler::release_held_htlc(struct LDKReleaseHeldHtlc message) {
+	(self.release_held_htlc)(self.this_arg, message);
+}
+inline LDK::CVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ AsyncPaymentsMessageHandler::release_pending_messages() {
+	LDK::CVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ ret = (self.release_pending_messages)(self.this_arg);
+	return ret;
+}
+inline LDK::COption_C2Tuple_OffersMessageResponseInstructionZZ OffersMessageHandler::handle_message(struct LDKOffersMessage message, struct LDKCOption_OffersContextZ context, struct LDKResponder responder) {
+	LDK::COption_C2Tuple_OffersMessageResponseInstructionZZ ret = (self.handle_message)(self.this_arg, message, context, responder);
 	return ret;
 }
-inline LDK::CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ OffersMessageHandler::release_pending_messages() {
-	LDK::CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ ret = (self.release_pending_messages)(self.this_arg);
+inline LDK::CVec_C2Tuple_OffersMessageMessageSendInstructionsZZ OffersMessageHandler::release_pending_messages() {
+	LDK::CVec_C2Tuple_OffersMessageMessageSendInstructionsZZ ret = (self.release_pending_messages)(self.this_arg);
 	return ret;
 }
 inline void BroadcasterInterface::broadcast_transactions(struct LDKCVec_TransactionZ txs) {
@@ -11339,6 +14098,14 @@ inline uint64_t OnionMessageContents::tlv_type() {
 	uint64_t ret = (self.tlv_type)(self.this_arg);
 	return ret;
 }
+inline LDK::Str OnionMessageContents::msg_type() {
+	LDK::Str ret = (self.msg_type)(self.this_arg);
+	return ret;
+}
+inline LDK::Str OnionMessageContents::debug_str() {
+	LDK::Str ret = (self.debug_str)(self.this_arg);
+	return ret;
+}
 inline LDK::CVec_MessageSendEventZ MessageSendEventsProvider::get_and_clear_pending_msg_events() {
 	LDK::CVec_MessageSendEventZ ret = (self.get_and_clear_pending_msg_events)(self.this_arg);
 	return ret;
@@ -11346,8 +14113,9 @@ inline LDK::CVec_MessageSendEventZ MessageSendEventsProvider::get_and_clear_pend
 inline void EventsProvider::process_pending_events(struct LDKEventHandler handler) {
 	(self.process_pending_events)(self.this_arg, handler);
 }
-inline void EventHandler::handle_event(struct LDKEvent event) {
-	(self.handle_event)(self.this_arg, event);
+inline LDK::CResult_NoneReplayEventZ EventHandler::handle_event(struct LDKEvent event) {
+	LDK::CResult_NoneReplayEventZ ret = (self.handle_event)(self.this_arg, event);
+	return ret;
 }
 inline LDK::CResult_COption_TypeZDecodeErrorZ CustomMessageReader::read(uint16_t message_type, struct LDKu8slice buffer) {
 	LDK::CResult_COption_TypeZDecodeErrorZ ret = (self.read)(self.this_arg, message_type, buffer);
@@ -11369,24 +14137,39 @@ inline LDK::CResult_OnionMessagePathNoneZ MessageRouter::find_path(struct LDKPub
 	LDK::CResult_OnionMessagePathNoneZ ret = (self.find_path)(self.this_arg, sender, peers, destination);
 	return ret;
 }
-inline LDK::COption_OnionMessageContentsZ CustomOnionMessageHandler::handle_custom_message(struct LDKOnionMessageContents msg) {
-	LDK::COption_OnionMessageContentsZ ret = (self.handle_custom_message)(self.this_arg, msg);
+inline LDK::CResult_CVec_BlindedMessagePathZNoneZ MessageRouter::create_blinded_paths(struct LDKPublicKey recipient, struct LDKMessageContext context, struct LDKCVec_PublicKeyZ peers) {
+	LDK::CResult_CVec_BlindedMessagePathZNoneZ ret = (self.create_blinded_paths)(self.this_arg, recipient, context, peers);
+	return ret;
+}
+inline LDK::CResult_CVec_BlindedMessagePathZNoneZ MessageRouter::create_compact_blinded_paths(struct LDKPublicKey recipient, struct LDKMessageContext context, struct LDKCVec_MessageForwardNodeZ peers) {
+	LDK::CResult_CVec_BlindedMessagePathZNoneZ ret = (self.create_compact_blinded_paths)(self.this_arg, recipient, context, peers);
+	return ret;
+}
+inline LDK::COption_C2Tuple_OnionMessageContentsResponseInstructionZZ CustomOnionMessageHandler::handle_custom_message(struct LDKOnionMessageContents message, struct LDKCOption_CVec_u8ZZ context, struct LDKResponder responder) {
+	LDK::COption_C2Tuple_OnionMessageContentsResponseInstructionZZ ret = (self.handle_custom_message)(self.this_arg, message, context, responder);
 	return ret;
 }
 inline LDK::CResult_COption_OnionMessageContentsZDecodeErrorZ CustomOnionMessageHandler::read_custom_message(uint64_t message_type, struct LDKu8slice buffer) {
 	LDK::CResult_COption_OnionMessageContentsZDecodeErrorZ ret = (self.read_custom_message)(self.this_arg, message_type, buffer);
 	return ret;
 }
-inline LDK::CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ CustomOnionMessageHandler::release_pending_custom_messages() {
-	LDK::CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ ret = (self.release_pending_custom_messages)(self.this_arg);
+inline LDK::CVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ CustomOnionMessageHandler::release_pending_custom_messages() {
+	LDK::CVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ ret = (self.release_pending_custom_messages)(self.this_arg);
+	return ret;
+}
+inline LDKPublicKey NodeIdLookUp::next_node_id(uint64_t short_channel_id) {
+	LDKPublicKey ret = (self.next_node_id)(self.this_arg, short_channel_id);
 	return ret;
 }
-inline LDK::ChannelMonitorUpdateStatus Persist::persist_new_channel(struct LDKOutPoint channel_id, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id) {
-	LDK::ChannelMonitorUpdateStatus ret = (self.persist_new_channel)(self.this_arg, channel_id, data, update_id);
+inline LDK::ChannelMonitorUpdateStatus Persist::persist_new_channel(struct LDKOutPoint channel_funding_outpoint, const struct LDKChannelMonitor *NONNULL_PTR monitor) {
+	LDK::ChannelMonitorUpdateStatus ret = (self.persist_new_channel)(self.this_arg, channel_funding_outpoint, monitor);
 	return ret;
 }
-inline LDK::ChannelMonitorUpdateStatus Persist::update_persisted_channel(struct LDKOutPoint channel_id, struct LDKChannelMonitorUpdate update, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id) {
-	LDK::ChannelMonitorUpdateStatus ret = (self.update_persisted_channel)(self.this_arg, channel_id, update, data, update_id);
+inline LDK::ChannelMonitorUpdateStatus Persist::update_persisted_channel(struct LDKOutPoint channel_funding_outpoint, struct LDKChannelMonitorUpdate monitor_update, const struct LDKChannelMonitor *NONNULL_PTR monitor) {
+	LDK::ChannelMonitorUpdateStatus ret = (self.update_persisted_channel)(self.this_arg, channel_funding_outpoint, monitor_update, monitor);
 	return ret;
 }
+inline void Persist::archive_persisted_channel(struct LDKOutPoint channel_funding_outpoint) {
+	(self.archive_persisted_channel)(self.this_arg, channel_funding_outpoint);
+}
 }