namespace LDK {
// Forward declarations
class Str;
+class RefundMaybeWithDerivedMetadataBuilder;
class Refund;
class Retry;
class RetryableSendFailure;
class PaymentSendFailure;
class ProbeSendFailure;
class RecipientOnionFields;
+class InvoiceWithExplicitSigningPubkeyBuilder;
+class InvoiceWithDerivedSigningPubkeyBuilder;
class UnsignedBolt12Invoice;
+class SignBolt12InvoiceFn;
class Bolt12Invoice;
class BlindedPayInfo;
class DelayedPaymentOutputDescriptor;
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;
class Payee;
class RouteHint;
class RouteHintHop;
+class FirstHopCandidate;
+class PublicHopCandidate;
+class PrivateHopCandidate;
+class BlindedPathCandidate;
+class OneHopBlindedPathCandidate;
+class CandidateRouteHop;
class ScoreLookUp;
class ScoreUpdate;
class Score;
class Bolt12InvoiceFeatures;
class BlindedHopFeatures;
class ChannelTypeFeatures;
+class OfferId;
+class OfferWithExplicitMetadataBuilder;
+class OfferWithDerivedMetadataBuilder;
class Offer;
class Amount;
class Quantity;
class NodeAnnouncementInfo;
class NodeAlias;
class NodeInfo;
+class ShortChannelIdError;
+class InboundHTLCErr;
class AnchorDescriptor;
class BumpTransactionEvent;
class Input;
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;
class UserConfig;
class APIError;
class TaggedHash;
+class SignError;
+class EcdsaChannelSigner;
+class WriteableEcdsaChannelSigner;
class ChannelMonitorUpdate;
class MonitorEvent;
class HTLCUpdate;
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 OpenChannel;
class OpenChannelV2;
+class CommonAcceptChannelFields;
class AcceptChannel;
class AcceptChannelV2;
class FundingCreated;
class FundingSigned;
class ChannelReady;
+class Stfu;
+class Splice;
+class SpliceAck;
+class SpliceLocked;
class TxAddInput;
class TxAddOutput;
class TxRemoveInput;
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 MessageSendEventsProvider;
class EventsProvider;
class EventHandler;
+class ElectrumSyncClient;
+class EsploraSyncClient;
class Bolt11ParseError;
class ParseOrSemanticError;
class Bolt11Invoice;
class TransactionU16LenLimited;
class UntrustedString;
class PrintableString;
+class ChannelId;
class CustomMessageReader;
class Type;
class ForwardNode;
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 DefaultMessageRouter;
class OnionMessagePath;
class Destination;
+class SendSuccess;
class SendError;
class CustomOnionMessageHandler;
class PeeledOnion;
class FilesystemStore;
+class TxSyncError;
+class NextMessageHop;
class BlindedPath;
+class IntroductionNode;
+class Direction;
+class NodeIdLookUp;
+class EmptyNodeIdLookUp;
class BlindedHop;
-class GraphSyncError;
class InvoiceError;
class ErroneousField;
+class TrackedSpendableOutput;
+class OutputSpendStatus;
+class OutputSweeper;
+class SpendingDelay;
+class DelayedPaymentBasepoint;
+class DelayedPaymentKey;
+class HtlcBasepoint;
+class HtlcKey;
+class RevocationBasepoint;
+class RevocationKey;
class MonitorUpdateId;
class Persist;
class LockedChannelMonitor;
class ChainMonitor;
-class CResult_LockedChannelMonitorNoneZ;
+class CResult_HtlcKeyDecodeErrorZ;
class CResult_TransactionU16LenLimitedNoneZ;
+class CVec_TrackedSpendableOutputZ;
+class CResult_LockedChannelMonitorNoneZ;
class CVec_C2Tuple_BlindedPayInfoBlindedPathZZ;
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 COption_NetworkUpdateZ;
class COption_u64Z;
-class CResult_CVec_u8ZPeerHandleErrorZ;
+class CResult_OnionPacketDecodeErrorZ;
class CResult_GossipTimestampFilterDecodeErrorZ;
+class CVec_ConfirmZ;
class CResult_RouteHintDecodeErrorZ;
class COption_FilterZ;
class C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ;
class CResult_RecipientOnionFieldsNoneZ;
class C2Tuple__u1632_u1632Z;
class CResult_CVec_StrZIOErrorZ;
-class CResult_ClosingSignedFeeRangeDecodeErrorZ;
+class COption_ECDSASignatureZ;
class CResult_TransactionNoneZ;
+class CResult_ClosingSignedFeeRangeDecodeErrorZ;
+class CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ;
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 CResult_PendingHTLCInfoInboundHTLCErrZ;
+class CResult_PendingHTLCInfoDecodeErrorZ;
+class CResult_HTLCOutputInCommitmentDecodeErrorZ;
+class CResult_ShutdownScriptInvalidShutdownScriptZ;
class COption_HTLCDestinationZ;
-class CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ;
class CVec_RouteHopZ;
-class CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ;
+class C2Tuple_PublicKeyCVec_SocketAddressZZ;
class CResult_CVec_UtxoZNoneZ;
class CResult_CVec_u8ZIOErrorZ;
+class CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ;
+class CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ;
+class CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ;
class C3Tuple_OffersMessageDestinationBlindedPathZ;
class CVec_ThirtyTwoBytesZ;
class CResult_ChannelMonitorUpdateStatusNoneZ;
class CResult_ClosingSignedDecodeErrorZ;
-class CResult_NonePaymentErrorZ;
class CVec_CResult_NoneAPIErrorZZ;
class CResult_SchnorrSignatureNoneZ;
class CResult_CounterpartyCommitmentSecretsDecodeErrorZ;
-class CResult_ReceiveTlvsDecodeErrorZ;
class CResult_HTLCDescriptorDecodeErrorZ;
class CVec_RecentPaymentDetailsZ;
class CVec_RouteHintHopZ;
class CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ;
class CResult_UntrustedStringDecodeErrorZ;
+class CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ;
class CVec_U5Z;
class CResult_PaymentParametersDecodeErrorZ;
class C2Tuple_ThirtyTwoBytesChannelMonitorZ;
class COption_U128Z;
+class CResult_DelayedPaymentBasepointDecodeErrorZ;
class C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ;
class CResult_TxAckRbfDecodeErrorZ;
class CResult_Bolt11InvoiceBolt11SemanticErrorZ;
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_COption_HTLCDestinationZDecodeErrorZ;
+class CResult_Bolt12OfferContextDecodeErrorZ;
class CResult_ThirtyTwoBytesNoneZ;
class C3Tuple_OnionMessageContentsDestinationBlindedPathZ;
class C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ;
+class CResult_SendSuccessSendErrorZ;
class CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ;
+class C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ;
class CResult_BlindedHopDecodeErrorZ;
-class C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ;
+class CResult_NoneLightningErrorZ;
class CResult_FixedPenaltyScorerDecodeErrorZ;
class CVec_BlindedPathZ;
-class CResult_NoneLightningErrorZ;
class CResult_NonePeerHandleErrorZ;
+class CResult_FinalOnionHopDataDecodeErrorZ;
class CResult_TrustedCommitmentTransactionNoneZ;
class CResult_COption_EventZDecodeErrorZ;
-class CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ;
+class CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ;
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_PaymentRelayDecodeErrorZ;
-class CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ;
+class CResult_NoneTxSyncErrorZ;
+class CResult_DescriptionCreationErrorZ;
class CResult_QueryShortChannelIdsDecodeErrorZ;
class CResult_VerifiedInvoiceRequestNoneZ;
class CResult_UpdateAddHTLCDecodeErrorZ;
+class CResult_PaymentRelayDecodeErrorZ;
+class COption_OutboundHTLCStateDetailsZ;
class COption_MonitorEventZ;
class COption_TypeZ;
class CResult_COption_TypeZDecodeErrorZ;
class CResult_COption_PathFailureZDecodeErrorZ;
class CResult_Bolt11InvoiceSignOrCreationErrorZ;
class CResult_UpdateFailHTLCDecodeErrorZ;
+class CResult_CVec_BlindedPathZNoneZ;
+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 COption_BigEndianScalarZ;
+class CVec_ChannelIdZ;
class CResult_PublicKeySecp256k1ErrorZ;
class CResult_CVec_ECDSASignatureZNoneZ;
class CVec_BlindedHopZ;
class CResult_COption_ClosureReasonZDecodeErrorZ;
class CResult_InvoiceErrorDecodeErrorZ;
+class C2Tuple_BestBlockOutputSweeperZ;
class C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ;
class CResult_RouteParametersDecodeErrorZ;
class CResult_PrivateRouteCreationErrorZ;
class CResult_NodeAliasDecodeErrorZ;
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 CResult_StrSecp256k1ErrorZ;
class CVec_ECDSASignatureZ;
class CResult_ChannelUpdateInfoDecodeErrorZ;
class CVec_UpdateFailHTLCZ;
class CVec_TxOutZ;
+class CVec_InboundHTLCDetailsZ;
+class CVec_OutboundHTLCDetailsZ;
class CResult_BuiltCommitmentTransactionDecodeErrorZ;
+class CResult_TrackedSpendableOutputDecodeErrorZ;
class CVec_SpendableOutputDescriptorZ;
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_PeeledOnionNoneZ;
class CResult_TxInitRbfDecodeErrorZ;
class COption_WriteableScoreZ;
class CVec_StrZ;
+class CResult_SpliceAckDecodeErrorZ;
class CResult_PositiveTimestampCreationErrorZ;
+class CVec_C2Tuple_OutPointChannelIdZZ;
class CResult_ChannelMonitorUpdateDecodeErrorZ;
class C2Tuple_BlindedPayInfoBlindedPathZ;
class CResult_ReplyChannelRangeDecodeErrorZ;
class CResult_TxRemoveOutputDecodeErrorZ;
class CResult_ChannelReestablishDecodeErrorZ;
class CResult_OnionMessageDecodeErrorZ;
-class CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ;
-class CResult_C2Tuple_CVec_u8ZusizeZNoneZ;
class CResult_Bolt11InvoiceParseOrSemanticErrorZ;
class CResult_InitFeaturesDecodeErrorZ;
class CResult_PublicKeyNoneZ;
class CResult_PingDecodeErrorZ;
+class CResult_RevocationKeyDecodeErrorZ;
+class CResult_ChannelIdDecodeErrorZ;
class CResult_BlindedHopFeaturesDecodeErrorZ;
class CVec_TransactionOutputsZ;
class COption_HTLCClaimZ;
class COption_boolZ;
-class CVec_CVec_u8ZZ;
-class CResult_ProbabilisticScorerDecodeErrorZ;
-class CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ;
class COption_StrZ;
+class CResult_ProbabilisticScorerDecodeErrorZ;
+class CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ;
class CResult_ShutdownScriptDecodeErrorZ;
+class CResult_ElectrumSyncClientTxSyncErrorZ;
class C2Tuple_usizeTransactionZ;
class CResult_NodeAnnouncementDecodeErrorZ;
class CVec_FutureZ;
class CVec_ChannelMonitorZ;
+class CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ;
class CResult_AcceptChannelV2DecodeErrorZ;
-class CResult_TxCreationKeysDecodeErrorZ;
class CResult_RouteHopDecodeErrorZ;
+class CResult_OfferIdDecodeErrorZ;
class CVec_HTLCOutputInCommitmentZ;
class CResult_CoinSelectionNoneZ;
-class C2Tuple_ThirtyTwoBytesPublicKeyZ;
+class CResult_TxCreationKeysDecodeErrorZ;
class CResult_SiPrefixBolt11ParseErrorZ;
-class CResult_BlindedPathDecodeErrorZ;
-class CVec_BalanceZ;
+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_BlindedPathDecodeErrorZ;
+class CResult_InboundHTLCDetailsDecodeErrorZ;
class C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ;
class CVec_PathZ;
class CResult_NetworkGraphDecodeErrorZ;
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_HolderCommitmentTransactionDecodeErrorZ;
+class CVec_ForwardNodeZ;
+class CResult_DelayedPaymentKeyDecodeErrorZ;
class CResult_InitDecodeErrorZ;
+class CResult_OfferBolt12SemanticErrorZ;
class CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ;
-class CResult_ClaimedHTLCDecodeErrorZ;
+class CResult_SpliceDecodeErrorZ;
class CResult_PaymentPurposeDecodeErrorZ;
-class CVec_MonitorUpdateIdZ;
+class CResult_ClaimedHTLCDecodeErrorZ;
class CResult_OutPointDecodeErrorZ;
class CVec_ChannelDetailsZ;
+class C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ;
class CResult_Bolt11InvoiceFeaturesDecodeErrorZ;
class CVec_MessageSendEventZ;
+class CVec_MonitorUpdateIdZ;
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_HostnameDecodeErrorZ;
class C2Tuple_u64u16Z;
class CVec_u64Z;
class CResult_NoneBolt12SemanticErrorZ;
class COption_SecretKeyZ;
-class CResult_ThirtyTwoBytesPaymentErrorZ;
+class COption_InboundHTLCStateDetailsZ;
+class CResult_UnknownPaymentContextDecodeErrorZ;
+class CResult_C2Tuple_CVec_u8Zu64ZNoneZ;
+class CResult_OutputSweeperDecodeErrorZ;
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 CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ;
+class C2Tuple_ChannelIdPublicKeyZ;
class CVec_WitnessZ;
class CResult_BlindedTailDecodeErrorZ;
class CResult_SocketAddressSocketAddressParseErrorZ;
class CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ;
class CResult_ChannelDerivationParametersDecodeErrorZ;
class CResult_PaymentConstraintsDecodeErrorZ;
+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_C2Tuple_u64CVec_u8ZZZ;
class CVec_PhantomRouteHintsZ;
+class CResult_OffersMessageDecodeErrorZ;
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_PendingHTLCRoutingDecodeErrorZ;
class C2Tuple_u64u64Z;
+class CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ;
+class CResult_ChannelDetailsDecodeErrorZ;
class CResult_CounterpartyChannelTransactionParametersDecodeErrorZ;
class CResult_RecipientOnionFieldsDecodeErrorZ;
class C2Tuple_u32TxOutZ;
+class CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ;
+class CResult_PaymentContextDecodeErrorZ;
class CVec_UtxoZ;
class CResult_ChannelConfigDecodeErrorZ;
class CVec_PrivateRouteZ;
class CResult_TxOutUtxoLookupErrorZ;
class CResult_BlindedPathNoneZ;
class COption_usizeZ;
-class CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ;
class CResult_NoneNoneZ;
class CResult_boolPeerHandleErrorZ;
class CResult_ChannelUpdateDecodeErrorZ;
class COption_ClosureReasonZ;
class CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ;
class CResult_TransactionU16LenLimitedDecodeErrorZ;
+class COption_AmountZ;
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:
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;
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;
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;
* 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
*/
inline void provide_channel_parameters(const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters);
};
-class EcdsaChannelSigner {
-private:
- LDKEcdsaChannelSigner self;
-public:
- EcdsaChannelSigner(const EcdsaChannelSigner&) = delete;
- EcdsaChannelSigner(EcdsaChannelSigner&& o) : self(o.self) { memset(&o, 0, sizeof(EcdsaChannelSigner)); }
- EcdsaChannelSigner(LDKEcdsaChannelSigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEcdsaChannelSigner)); }
- operator LDKEcdsaChannelSigner() && { LDKEcdsaChannelSigner res = self; memset(&self, 0, sizeof(LDKEcdsaChannelSigner)); return res; }
- ~EcdsaChannelSigner() { EcdsaChannelSigner_free(self); }
- EcdsaChannelSigner& operator=(EcdsaChannelSigner&& o) { EcdsaChannelSigner_free(self); self = o.self; memset(&o, 0, sizeof(EcdsaChannelSigner)); return *this; }
- LDKEcdsaChannelSigner* operator &() { return &self; }
- LDKEcdsaChannelSigner* operator ->() { return &self; }
- const LDKEcdsaChannelSigner* operator &() const { return &self; }
- const LDKEcdsaChannelSigner* operator ->() const { return &self; }
- /**
- * Create a signature for a counterparty's commitment transaction and associated HTLC transactions.
- *
- * 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 outgoing HTLCs that were fulfilled since the last commitment are provided.
- * A validating signer should ensure that an HTLC output is removed only when the matching
- * preimage is provided, or when the value to holder is restored.
- *
- * Note 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 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]);
- /**
- * 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.
- */
- 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;
*/
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;
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`.
* 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
*/
* 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.
*
*/
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;
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;
* 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 [`BlindedPath`]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_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ create_blinded_payment_paths(struct LDKPublicKey recipient, struct LDKCVec_ChannelDetailsZ first_hops, struct LDKReceiveTlvs tlvs, uint64_t amount_msats);
};
class ScorerAccountingForInFlightHtlcs {
private:
const LDKRouteHintHop* operator &() const { return &self; }
const LDKRouteHintHop* operator ->() const { return &self; }
};
+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 ScoreLookUp {
private:
LDKScoreLookUp self;
* [`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:
/**
* 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:
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.
* 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:
* 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:
const LDKChannelTypeFeatures* operator &() const { return &self; }
const LDKChannelTypeFeatures* operator ->() const { return &self; }
};
+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;
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;
/**
* 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:
* 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:
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;
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;
const LDKAPIError* operator &() const { return &self; }
const LDKAPIError* operator ->() const { return &self; }
};
-class TaggedHash {
+class TaggedHash {
+private:
+ LDKTaggedHash self;
+public:
+ TaggedHash(const TaggedHash&) = delete;
+ TaggedHash(TaggedHash&& o) : self(o.self) { memset(&o, 0, sizeof(TaggedHash)); }
+ TaggedHash(LDKTaggedHash&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTaggedHash)); }
+ operator LDKTaggedHash() && { LDKTaggedHash res = self; memset(&self, 0, sizeof(LDKTaggedHash)); return res; }
+ ~TaggedHash() { TaggedHash_free(self); }
+ TaggedHash& operator=(TaggedHash&& o) { TaggedHash_free(self); self = o.self; memset(&o, 0, sizeof(TaggedHash)); return *this; }
+ LDKTaggedHash* operator &() { return &self; }
+ LDKTaggedHash* operator ->() { return &self; }
+ const LDKTaggedHash* operator &() const { return &self; }
+ const LDKTaggedHash* operator ->() const { return &self; }
+};
+class SignError {
+private:
+ LDKSignError self;
+public:
+ 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 EcdsaChannelSigner {
+private:
+ LDKEcdsaChannelSigner self;
+public:
+ EcdsaChannelSigner(const EcdsaChannelSigner&) = delete;
+ EcdsaChannelSigner(EcdsaChannelSigner&& o) : self(o.self) { memset(&o, 0, sizeof(EcdsaChannelSigner)); }
+ EcdsaChannelSigner(LDKEcdsaChannelSigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEcdsaChannelSigner)); }
+ operator LDKEcdsaChannelSigner() && { LDKEcdsaChannelSigner res = self; memset(&self, 0, sizeof(LDKEcdsaChannelSigner)); return res; }
+ ~EcdsaChannelSigner() { EcdsaChannelSigner_free(self); }
+ EcdsaChannelSigner& operator=(EcdsaChannelSigner&& o) { EcdsaChannelSigner_free(self); self = o.self; memset(&o, 0, sizeof(EcdsaChannelSigner)); return *this; }
+ LDKEcdsaChannelSigner* operator &() { return &self; }
+ LDKEcdsaChannelSigner* operator ->() { return &self; }
+ const LDKEcdsaChannelSigner* operator &() const { return &self; }
+ const LDKEcdsaChannelSigner* operator ->() const { return &self; }
+ /**
+ * Create a signature for a counterparty's commitment transaction and associated HTLC transactions.
+ *
+ * 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 WriteableEcdsaChannelSigner {
private:
- LDKTaggedHash self;
+ LDKWriteableEcdsaChannelSigner self;
public:
- TaggedHash(const TaggedHash&) = delete;
- TaggedHash(TaggedHash&& o) : self(o.self) { memset(&o, 0, sizeof(TaggedHash)); }
- TaggedHash(LDKTaggedHash&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTaggedHash)); }
- operator LDKTaggedHash() && { LDKTaggedHash res = self; memset(&self, 0, sizeof(LDKTaggedHash)); return res; }
- ~TaggedHash() { TaggedHash_free(self); }
- TaggedHash& operator=(TaggedHash&& o) { TaggedHash_free(self); self = o.self; memset(&o, 0, sizeof(TaggedHash)); return *this; }
- LDKTaggedHash* operator &() { return &self; }
- LDKTaggedHash* operator ->() { return &self; }
- const LDKTaggedHash* operator &() const { return &self; }
- const LDKTaggedHash* operator ->() const { return &self; }
+ WriteableEcdsaChannelSigner(const WriteableEcdsaChannelSigner&) = delete;
+ WriteableEcdsaChannelSigner(WriteableEcdsaChannelSigner&& o) : self(o.self) { memset(&o, 0, sizeof(WriteableEcdsaChannelSigner)); }
+ WriteableEcdsaChannelSigner(LDKWriteableEcdsaChannelSigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWriteableEcdsaChannelSigner)); }
+ operator LDKWriteableEcdsaChannelSigner() && { LDKWriteableEcdsaChannelSigner res = self; memset(&self, 0, sizeof(LDKWriteableEcdsaChannelSigner)); return res; }
+ ~WriteableEcdsaChannelSigner() { WriteableEcdsaChannelSigner_free(self); }
+ WriteableEcdsaChannelSigner& operator=(WriteableEcdsaChannelSigner&& o) { WriteableEcdsaChannelSigner_free(self); self = o.self; memset(&o, 0, sizeof(WriteableEcdsaChannelSigner)); return *this; }
+ LDKWriteableEcdsaChannelSigner* operator &() { return &self; }
+ LDKWriteableEcdsaChannelSigner* operator ->() { return &self; }
+ const LDKWriteableEcdsaChannelSigner* operator &() const { return &self; }
+ const LDKWriteableEcdsaChannelSigner* operator ->() const { return &self; }
};
class ChannelMonitorUpdate {
private:
*/
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;
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;
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);
/**
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;
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;
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;
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 OpenChannel {
private:
LDKOpenChannel self;
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;
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 Splice {
+private:
+ LDKSplice self;
+public:
+ Splice(const Splice&) = delete;
+ Splice(Splice&& o) : self(o.self) { memset(&o, 0, sizeof(Splice)); }
+ Splice(LDKSplice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSplice)); }
+ operator LDKSplice() && { LDKSplice res = self; memset(&self, 0, sizeof(LDKSplice)); return res; }
+ ~Splice() { Splice_free(self); }
+ Splice& operator=(Splice&& o) { Splice_free(self); self = o.self; memset(&o, 0, sizeof(Splice)); return *this; }
+ LDKSplice* operator &() { return &self; }
+ LDKSplice* operator ->() { return &self; }
+ const LDKSplice* operator &() const { return &self; }
+ const LDKSplice* 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;
* 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.
*/
LDKOnionMessageHandler* operator ->() { return &self; }
const LDKOnionMessageHandler* operator &() const { return &self; }
const LDKOnionMessageHandler* operator ->() const { return &self; }
+ /**
+ * Because much of the lightning network does not yet support forwarding onion messages, we
+ * may need to directly connect to a node which will forward a message for us. In such a case,
+ * this method will return the set of nodes which need connection by node_id and the
+ * corresponding socket addresses where they may accept incoming connections.
+ *
+ * Thus, this method should be polled regularly to detect messages await such a direct
+ * connection.
+ */
+ inline LDK::CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ get_and_clear_connections_needed();
/**
* Handle an incoming `onion_message` message from the given peer.
*/
* 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`]
*/
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;
const LDKRecord* operator &() const { return &self; }
const LDKRecord* operator ->() const { return &self; }
};
-class Logger {
+class Logger {
+private:
+ LDKLogger self;
+public:
+ Logger(const Logger&) = delete;
+ Logger(Logger&& o) : self(o.self) { memset(&o, 0, sizeof(Logger)); }
+ Logger(LDKLogger&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLogger)); }
+ operator LDKLogger() && { LDKLogger res = self; memset(&self, 0, sizeof(LDKLogger)); return res; }
+ ~Logger() { Logger_free(self); }
+ Logger& operator=(Logger&& o) { Logger_free(self); self = o.self; memset(&o, 0, sizeof(Logger)); return *this; }
+ LDKLogger* operator &() { return &self; }
+ LDKLogger* operator ->() { return &self; }
+ const LDKLogger* operator &() const { return &self; }
+ const LDKLogger* operator ->() const { return &self; }
+ /**
+ * Logs the [`Record`].
+ */
+ inline void log(struct LDKRecord record);
+};
+class InboundHTLCStateDetails {
+private:
+ LDKInboundHTLCStateDetails self;
+public:
+ 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:
- LDKLogger self;
+ LDKChannelShutdownState self;
public:
- Logger(const Logger&) = delete;
- Logger(Logger&& o) : self(o.self) { memset(&o, 0, sizeof(Logger)); }
- Logger(LDKLogger&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLogger)); }
- operator LDKLogger() && { LDKLogger res = self; memset(&self, 0, sizeof(LDKLogger)); return res; }
- ~Logger() { Logger_free(self); }
- Logger& operator=(Logger&& o) { Logger_free(self); self = o.self; memset(&o, 0, sizeof(Logger)); return *this; }
- LDKLogger* operator &() { return &self; }
- LDKLogger* operator ->() { return &self; }
- const LDKLogger* operator &() const { return &self; }
- const LDKLogger* operator ->() const { return &self; }
- /**
- * Logs the `Record`
- */
- inline void log(const struct LDKRecord *NONNULL_PTR record);
+ 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:
*
* The returned [`OffersMessage`], if any, is enqueued to be sent by [`OnionMessenger`].
*
- * [`OnionMessenger`]: crate::onion_message::OnionMessenger
+ * [`OnionMessenger`]: crate::onion_message::messenger::OnionMessenger
*/
inline LDK::COption_OffersMessageZ handle_message(struct LDKOffersMessage message);
/**
* 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);
};
* Returns the TLV type identifying the message contents. MUST be >= 64.
*/
inline uint64_t tlv_type();
+ /**
+ * Return a human-readable "debug" string describing this object
+ */
+ inline LDK::Str debug_str();
};
class PaymentPurpose {
private:
*/
inline void handle_event(struct LDKEvent event);
};
+class ElectrumSyncClient {
+private:
+ LDKElectrumSyncClient self;
+public:
+ ElectrumSyncClient(const ElectrumSyncClient&) = delete;
+ ElectrumSyncClient(ElectrumSyncClient&& o) : self(o.self) { memset(&o, 0, sizeof(ElectrumSyncClient)); }
+ ElectrumSyncClient(LDKElectrumSyncClient&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKElectrumSyncClient)); }
+ operator LDKElectrumSyncClient() && { LDKElectrumSyncClient res = self; memset(&self, 0, sizeof(LDKElectrumSyncClient)); return res; }
+ ~ElectrumSyncClient() { ElectrumSyncClient_free(self); }
+ ElectrumSyncClient& operator=(ElectrumSyncClient&& o) { ElectrumSyncClient_free(self); self = o.self; memset(&o, 0, sizeof(ElectrumSyncClient)); return *this; }
+ LDKElectrumSyncClient* operator &() { return &self; }
+ LDKElectrumSyncClient* operator ->() { return &self; }
+ const LDKElectrumSyncClient* operator &() const { return &self; }
+ const LDKElectrumSyncClient* operator ->() const { return &self; }
+};
+class EsploraSyncClient {
+private:
+ LDKEsploraSyncClient self;
+public:
+ EsploraSyncClient(const EsploraSyncClient&) = delete;
+ EsploraSyncClient(EsploraSyncClient&& o) : self(o.self) { memset(&o, 0, sizeof(EsploraSyncClient)); }
+ EsploraSyncClient(LDKEsploraSyncClient&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEsploraSyncClient)); }
+ operator LDKEsploraSyncClient() && { LDKEsploraSyncClient res = self; memset(&self, 0, sizeof(LDKEsploraSyncClient)); return res; }
+ ~EsploraSyncClient() { EsploraSyncClient_free(self); }
+ EsploraSyncClient& operator=(EsploraSyncClient&& o) { EsploraSyncClient_free(self); self = o.self; memset(&o, 0, sizeof(EsploraSyncClient)); return *this; }
+ LDKEsploraSyncClient* operator &() { return &self; }
+ LDKEsploraSyncClient* operator ->() { return &self; }
+ const LDKEsploraSyncClient* operator &() const { return &self; }
+ const LDKEsploraSyncClient* operator ->() const { return &self; }
+};
class Bolt11ParseError {
private:
LDKBolt11ParseError self;
const LDKPrintableString* operator &() const { return &self; }
const LDKPrintableString* operator ->() const { return &self; }
};
+class ChannelId {
+private:
+ LDKChannelId self;
+public:
+ 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:
LDKCustomMessageReader self;
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:
* 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 [`BlindedPath`]s to the `recipient` node. The nodes in `peers` are assumed to be
+ * direct peers with the `recipient`.
+ */
+ inline LDK::CResult_CVec_BlindedPathZNoneZ create_blinded_paths(struct LDKPublicKey recipient, struct LDKCVec_PublicKeyZ peers);
};
class DefaultMessageRouter {
private:
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;
const LDKFilesystemStore* operator &() const { return &self; }
const LDKFilesystemStore* operator ->() const { return &self; }
};
+class TxSyncError {
+private:
+ LDKTxSyncError self;
+public:
+ TxSyncError(const TxSyncError&) = delete;
+ TxSyncError(TxSyncError&& o) : self(o.self) { memset(&o, 0, sizeof(TxSyncError)); }
+ TxSyncError(LDKTxSyncError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxSyncError)); }
+ operator LDKTxSyncError() && { LDKTxSyncError res = self; memset(&self, 0, sizeof(LDKTxSyncError)); return res; }
+ TxSyncError& operator=(TxSyncError&& o) { self = o.self; memset(&o, 0, sizeof(TxSyncError)); return *this; }
+ LDKTxSyncError* operator &() { return &self; }
+ LDKTxSyncError* operator ->() { return &self; }
+ const LDKTxSyncError* operator &() const { return &self; }
+ const LDKTxSyncError* 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 BlindedPath {
private:
LDKBlindedPath self;
const LDKBlindedPath* operator &() const { return &self; }
const LDKBlindedPath* 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;
const LDKBlindedHop* operator &() const { return &self; }
const LDKBlindedHop* 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 InvoiceError {
private:
LDKInvoiceError self;
const LDKErroneousField* operator &() const { return &self; }
const LDKErroneousField* 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 MonitorUpdateId {
private:
LDKMonitorUpdateId self;
* [`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 data, struct LDKMonitorUpdateId update_id);
/**
* Update one channel's data. The provided [`ChannelMonitor`] has already applied the given
* update.
*
* Note that 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 update, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id);
+ /**
+ * 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:
const LDKChainMonitor* operator &() const { return &self; }
const LDKChainMonitor* operator ->() const { return &self; }
};
-class CResult_LockedChannelMonitorNoneZ {
+class CResult_HtlcKeyDecodeErrorZ {
private:
- LDKCResult_LockedChannelMonitorNoneZ self;
+ LDKCResult_HtlcKeyDecodeErrorZ 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; }
+ 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:
const LDKCResult_TransactionU16LenLimitedNoneZ* operator &() const { return &self; }
const LDKCResult_TransactionU16LenLimitedNoneZ* operator ->() const { return &self; }
};
+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:
+ 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 CVec_C2Tuple_BlindedPayInfoBlindedPathZZ {
private:
LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ self;
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:
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;
const LDKCOption_MaxDustHTLCExposureZ* operator &() const { return &self; }
const LDKCOption_MaxDustHTLCExposureZ* operator ->() const { return &self; }
};
-class CResult_NoneSendErrorZ {
-private:
- LDKCResult_NoneSendErrorZ self;
-public:
- CResult_NoneSendErrorZ(const CResult_NoneSendErrorZ&) = delete;
- CResult_NoneSendErrorZ(CResult_NoneSendErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneSendErrorZ)); }
- CResult_NoneSendErrorZ(LDKCResult_NoneSendErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneSendErrorZ)); }
- operator LDKCResult_NoneSendErrorZ() && { LDKCResult_NoneSendErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneSendErrorZ)); return res; }
- ~CResult_NoneSendErrorZ() { CResult_NoneSendErrorZ_free(self); }
- CResult_NoneSendErrorZ& operator=(CResult_NoneSendErrorZ&& o) { CResult_NoneSendErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneSendErrorZ)); return *this; }
- LDKCResult_NoneSendErrorZ* operator &() { return &self; }
- LDKCResult_NoneSendErrorZ* operator ->() { return &self; }
- const LDKCResult_NoneSendErrorZ* operator &() const { return &self; }
- const LDKCResult_NoneSendErrorZ* operator ->() const { return &self; }
-};
-class C2Tuple_CVec_u8ZusizeZ {
-private:
- LDKC2Tuple_CVec_u8ZusizeZ 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; }
-};
class COption_OffersMessageZ {
private:
LDKCOption_OffersMessageZ self;
const LDKCOption_OffersMessageZ* operator &() const { return &self; }
const LDKCOption_OffersMessageZ* 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 COption_NetworkUpdateZ {
private:
LDKCOption_NetworkUpdateZ self;
const LDKCOption_u64Z* operator &() const { return &self; }
const LDKCOption_u64Z* operator ->() const { return &self; }
};
-class CResult_CVec_u8ZPeerHandleErrorZ {
+class CResult_OnionPacketDecodeErrorZ {
private:
- LDKCResult_CVec_u8ZPeerHandleErrorZ self;
+ LDKCResult_OnionPacketDecodeErrorZ 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; }
+ 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 CResult_GossipTimestampFilterDecodeErrorZ {
private:
const LDKCResult_GossipTimestampFilterDecodeErrorZ* operator &() const { return &self; }
const LDKCResult_GossipTimestampFilterDecodeErrorZ* operator ->() const { return &self; }
};
+class CVec_ConfirmZ {
+private:
+ LDKCVec_ConfirmZ self;
+public:
+ CVec_ConfirmZ(const CVec_ConfirmZ&) = delete;
+ CVec_ConfirmZ(CVec_ConfirmZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ConfirmZ)); }
+ CVec_ConfirmZ(LDKCVec_ConfirmZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ConfirmZ)); }
+ operator LDKCVec_ConfirmZ() && { LDKCVec_ConfirmZ res = self; memset(&self, 0, sizeof(LDKCVec_ConfirmZ)); return res; }
+ ~CVec_ConfirmZ() { CVec_ConfirmZ_free(self); }
+ CVec_ConfirmZ& operator=(CVec_ConfirmZ&& o) { CVec_ConfirmZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ConfirmZ)); return *this; }
+ LDKCVec_ConfirmZ* operator &() { return &self; }
+ LDKCVec_ConfirmZ* operator ->() { return &self; }
+ const LDKCVec_ConfirmZ* operator &() const { return &self; }
+ const LDKCVec_ConfirmZ* operator ->() const { return &self; }
+};
class CResult_RouteHintDecodeErrorZ {
private:
LDKCResult_RouteHintDecodeErrorZ self;
const LDKCResult_CVec_StrZIOErrorZ* operator &() const { return &self; }
const LDKCResult_CVec_StrZIOErrorZ* operator ->() const { return &self; }
};
-class CResult_ClosingSignedFeeRangeDecodeErrorZ {
+class COption_ECDSASignatureZ {
private:
- LDKCResult_ClosingSignedFeeRangeDecodeErrorZ self;
+ LDKCOption_ECDSASignatureZ self;
public:
- CResult_ClosingSignedFeeRangeDecodeErrorZ(const CResult_ClosingSignedFeeRangeDecodeErrorZ&) = delete;
- CResult_ClosingSignedFeeRangeDecodeErrorZ(CResult_ClosingSignedFeeRangeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ClosingSignedFeeRangeDecodeErrorZ)); }
- CResult_ClosingSignedFeeRangeDecodeErrorZ(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ)); }
- operator LDKCResult_ClosingSignedFeeRangeDecodeErrorZ() && { LDKCResult_ClosingSignedFeeRangeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ)); return res; }
- ~CResult_ClosingSignedFeeRangeDecodeErrorZ() { CResult_ClosingSignedFeeRangeDecodeErrorZ_free(self); }
- CResult_ClosingSignedFeeRangeDecodeErrorZ& operator=(CResult_ClosingSignedFeeRangeDecodeErrorZ&& o) { CResult_ClosingSignedFeeRangeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ClosingSignedFeeRangeDecodeErrorZ)); return *this; }
- LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator &() { return &self; }
- LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator ->() const { return &self; }
+ 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_TransactionNoneZ {
private:
const LDKCResult_TransactionNoneZ* operator &() const { return &self; }
const LDKCResult_TransactionNoneZ* operator ->() const { return &self; }
};
+class CResult_ClosingSignedFeeRangeDecodeErrorZ {
+private:
+ LDKCResult_ClosingSignedFeeRangeDecodeErrorZ self;
+public:
+ CResult_ClosingSignedFeeRangeDecodeErrorZ(const CResult_ClosingSignedFeeRangeDecodeErrorZ&) = delete;
+ CResult_ClosingSignedFeeRangeDecodeErrorZ(CResult_ClosingSignedFeeRangeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ClosingSignedFeeRangeDecodeErrorZ)); }
+ CResult_ClosingSignedFeeRangeDecodeErrorZ(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ)); }
+ operator LDKCResult_ClosingSignedFeeRangeDecodeErrorZ() && { LDKCResult_ClosingSignedFeeRangeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ)); return res; }
+ ~CResult_ClosingSignedFeeRangeDecodeErrorZ() { CResult_ClosingSignedFeeRangeDecodeErrorZ_free(self); }
+ CResult_ClosingSignedFeeRangeDecodeErrorZ& operator=(CResult_ClosingSignedFeeRangeDecodeErrorZ&& o) { CResult_ClosingSignedFeeRangeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ClosingSignedFeeRangeDecodeErrorZ)); return *this; }
+ LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_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 CResult_CommitmentSignedDecodeErrorZ {
private:
LDKCResult_CommitmentSignedDecodeErrorZ self;
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:
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;
const LDKCOption_APIErrorZ* operator &() const { return &self; }
const LDKCOption_APIErrorZ* operator ->() const { return &self; }
};
-class CResult_QueryChannelRangeDecodeErrorZ {
+class CVec_PeerDetailsZ {
private:
- LDKCResult_QueryChannelRangeDecodeErrorZ self;
+ LDKCVec_PeerDetailsZ self;
public:
- CResult_QueryChannelRangeDecodeErrorZ(const CResult_QueryChannelRangeDecodeErrorZ&) = delete;
- CResult_QueryChannelRangeDecodeErrorZ(CResult_QueryChannelRangeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_QueryChannelRangeDecodeErrorZ)); }
- CResult_QueryChannelRangeDecodeErrorZ(LDKCResult_QueryChannelRangeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ)); }
- operator LDKCResult_QueryChannelRangeDecodeErrorZ() && { LDKCResult_QueryChannelRangeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ)); return res; }
- ~CResult_QueryChannelRangeDecodeErrorZ() { CResult_QueryChannelRangeDecodeErrorZ_free(self); }
- CResult_QueryChannelRangeDecodeErrorZ& operator=(CResult_QueryChannelRangeDecodeErrorZ&& o) { CResult_QueryChannelRangeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_QueryChannelRangeDecodeErrorZ)); return *this; }
- LDKCResult_QueryChannelRangeDecodeErrorZ* operator &() { return &self; }
- LDKCResult_QueryChannelRangeDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_QueryChannelRangeDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_QueryChannelRangeDecodeErrorZ* operator ->() const { return &self; }
+ 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 CVec_TransactionZ {
+class CResult_u64ShortChannelIdErrorZ {
private:
- LDKCVec_TransactionZ self;
+ LDKCResult_u64ShortChannelIdErrorZ 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; }
+ 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;
+public:
+ CResult_QueryChannelRangeDecodeErrorZ(const CResult_QueryChannelRangeDecodeErrorZ&) = delete;
+ CResult_QueryChannelRangeDecodeErrorZ(CResult_QueryChannelRangeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_QueryChannelRangeDecodeErrorZ)); }
+ CResult_QueryChannelRangeDecodeErrorZ(LDKCResult_QueryChannelRangeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ)); }
+ operator LDKCResult_QueryChannelRangeDecodeErrorZ() && { LDKCResult_QueryChannelRangeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ)); return res; }
+ ~CResult_QueryChannelRangeDecodeErrorZ() { CResult_QueryChannelRangeDecodeErrorZ_free(self); }
+ CResult_QueryChannelRangeDecodeErrorZ& operator=(CResult_QueryChannelRangeDecodeErrorZ&& o) { CResult_QueryChannelRangeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_QueryChannelRangeDecodeErrorZ)); return *this; }
+ LDKCResult_QueryChannelRangeDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_QueryChannelRangeDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_QueryChannelRangeDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_QueryChannelRangeDecodeErrorZ* operator ->() const { return &self; }
};
class CVec_InputZ {
private:
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;
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;
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:
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;
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;
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:
const LDKCResult_ShutdownScriptNoneZ* operator &() const { return &self; }
const LDKCResult_ShutdownScriptNoneZ* 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_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_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_ShutdownScriptInvalidShutdownScriptZ {
+private:
+ LDKCResult_ShutdownScriptInvalidShutdownScriptZ self;
+public:
+ CResult_ShutdownScriptInvalidShutdownScriptZ(const CResult_ShutdownScriptInvalidShutdownScriptZ&) = delete;
+ CResult_ShutdownScriptInvalidShutdownScriptZ(CResult_ShutdownScriptInvalidShutdownScriptZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ShutdownScriptInvalidShutdownScriptZ)); }
+ CResult_ShutdownScriptInvalidShutdownScriptZ(LDKCResult_ShutdownScriptInvalidShutdownScriptZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ)); }
+ operator LDKCResult_ShutdownScriptInvalidShutdownScriptZ() && { LDKCResult_ShutdownScriptInvalidShutdownScriptZ res = self; memset(&self, 0, sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ)); return res; }
+ ~CResult_ShutdownScriptInvalidShutdownScriptZ() { CResult_ShutdownScriptInvalidShutdownScriptZ_free(self); }
+ CResult_ShutdownScriptInvalidShutdownScriptZ& operator=(CResult_ShutdownScriptInvalidShutdownScriptZ&& o) { CResult_ShutdownScriptInvalidShutdownScriptZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ShutdownScriptInvalidShutdownScriptZ)); return *this; }
+ LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator &() { return &self; }
+ LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator ->() { return &self; }
+ const LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator &() const { return &self; }
+ const LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator ->() const { return &self; }
+};
class COption_HTLCDestinationZ {
private:
LDKCOption_HTLCDestinationZ self;
const LDKCOption_HTLCDestinationZ* operator &() const { return &self; }
const LDKCOption_HTLCDestinationZ* operator ->() const { return &self; }
};
-class CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ {
-private:
- LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ self;
-public:
- CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ(const CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ&) = delete;
- CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ(CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ)); }
- CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ(LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ)); }
- operator LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ() && { LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ)); return res; }
- ~CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ() { CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(self); }
- CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ& operator=(CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ&& o) { CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ)); return *this; }
- LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ* operator &() { return &self; }
- LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ* operator ->() { return &self; }
- const LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ* operator &() const { return &self; }
- const LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ* operator ->() const { return &self; }
-};
class CVec_RouteHopZ {
private:
LDKCVec_RouteHopZ self;
const LDKCVec_RouteHopZ* operator &() const { return &self; }
const LDKCVec_RouteHopZ* operator ->() const { return &self; }
};
-class CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ {
+class C2Tuple_PublicKeyCVec_SocketAddressZZ {
private:
- LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ self;
+ LDKC2Tuple_PublicKeyCVec_SocketAddressZZ 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; }
+ C2Tuple_PublicKeyCVec_SocketAddressZZ(const C2Tuple_PublicKeyCVec_SocketAddressZZ&) = delete;
+ C2Tuple_PublicKeyCVec_SocketAddressZZ(C2Tuple_PublicKeyCVec_SocketAddressZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_PublicKeyCVec_SocketAddressZZ)); }
+ C2Tuple_PublicKeyCVec_SocketAddressZZ(LDKC2Tuple_PublicKeyCVec_SocketAddressZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_PublicKeyCVec_SocketAddressZZ)); }
+ operator LDKC2Tuple_PublicKeyCVec_SocketAddressZZ() && { LDKC2Tuple_PublicKeyCVec_SocketAddressZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_PublicKeyCVec_SocketAddressZZ)); return res; }
+ ~C2Tuple_PublicKeyCVec_SocketAddressZZ() { C2Tuple_PublicKeyCVec_SocketAddressZZ_free(self); }
+ C2Tuple_PublicKeyCVec_SocketAddressZZ& operator=(C2Tuple_PublicKeyCVec_SocketAddressZZ&& o) { C2Tuple_PublicKeyCVec_SocketAddressZZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_PublicKeyCVec_SocketAddressZZ)); return *this; }
+ LDKC2Tuple_PublicKeyCVec_SocketAddressZZ* operator &() { return &self; }
+ LDKC2Tuple_PublicKeyCVec_SocketAddressZZ* operator ->() { return &self; }
+ const LDKC2Tuple_PublicKeyCVec_SocketAddressZZ* operator &() const { return &self; }
+ const LDKC2Tuple_PublicKeyCVec_SocketAddressZZ* operator ->() const { return &self; }
};
class CResult_CVec_UtxoZNoneZ {
private:
const LDKCResult_CVec_u8ZIOErrorZ* operator &() const { return &self; }
const LDKCResult_CVec_u8ZIOErrorZ* 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_UnsignedBolt12InvoiceBolt12SemanticErrorZ {
+private:
+ LDKCResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ self;
+public:
+ 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_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ {
+private:
+ LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ self;
+public:
+ CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ(const CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ&) = delete;
+ CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ(CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ)); }
+ CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ(LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ)); }
+ operator LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ() && { LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ)); return res; }
+ ~CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ() { CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(self); }
+ CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ& operator=(CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ&& o) { CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ)); return *this; }
+ LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ* operator &() { return &self; }
+ LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ* operator ->() { return &self; }
+ const LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ* operator &() const { return &self; }
+ const LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ* operator ->() const { return &self; }
+};
class C3Tuple_OffersMessageDestinationBlindedPathZ {
private:
LDKC3Tuple_OffersMessageDestinationBlindedPathZ self;
const LDKCResult_ClosingSignedDecodeErrorZ* operator &() const { return &self; }
const LDKCResult_ClosingSignedDecodeErrorZ* operator ->() const { return &self; }
};
-class CResult_NonePaymentErrorZ {
-private:
- LDKCResult_NonePaymentErrorZ self;
-public:
- CResult_NonePaymentErrorZ(const CResult_NonePaymentErrorZ&) = delete;
- CResult_NonePaymentErrorZ(CResult_NonePaymentErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NonePaymentErrorZ)); }
- CResult_NonePaymentErrorZ(LDKCResult_NonePaymentErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NonePaymentErrorZ)); }
- operator LDKCResult_NonePaymentErrorZ() && { LDKCResult_NonePaymentErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NonePaymentErrorZ)); return res; }
- ~CResult_NonePaymentErrorZ() { CResult_NonePaymentErrorZ_free(self); }
- CResult_NonePaymentErrorZ& operator=(CResult_NonePaymentErrorZ&& o) { CResult_NonePaymentErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NonePaymentErrorZ)); return *this; }
- LDKCResult_NonePaymentErrorZ* operator &() { return &self; }
- LDKCResult_NonePaymentErrorZ* operator ->() { return &self; }
- const LDKCResult_NonePaymentErrorZ* operator &() const { return &self; }
- const LDKCResult_NonePaymentErrorZ* operator ->() const { return &self; }
-};
class CVec_CResult_NoneAPIErrorZZ {
private:
LDKCVec_CResult_NoneAPIErrorZZ self;
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;
const LDKCResult_UntrustedStringDecodeErrorZ* operator &() const { return &self; }
const LDKCResult_UntrustedStringDecodeErrorZ* operator ->() const { return &self; }
};
+class CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ {
+private:
+ LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ self;
+public:
+ 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 CVec_U5Z {
private:
LDKCVec_U5Z self;
const LDKCOption_U128Z* operator &() const { return &self; }
const LDKCOption_U128Z* 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_ThirtyTwoBytesThirtyTwoBytesZ {
private:
LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ self;
const LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* operator &() const { return &self; }
const LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* operator ->() const { return &self; }
};
+class CResult_ChannelIdAPIErrorZ {
+private:
+ LDKCResult_ChannelIdAPIErrorZ self;
+public:
+ 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:
LDKCResult_CVec_u8ZNoneZ self;
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;
const LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* operator &() const { return &self; }
const LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* operator ->() const { return &self; }
};
+class CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ {
+private:
+ LDKCResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ self;
+public:
+ 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:
LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ self;
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;
const LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ* operator &() const { return &self; }
const LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ* 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 CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ {
private:
LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ self;
const LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ* operator &() const { return &self; }
const LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ* 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:
LDKCResult_BlindedHopDecodeErrorZ self;
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:
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;
const LDKCResult_NonePeerHandleErrorZ* operator &() const { return &self; }
const LDKCResult_NonePeerHandleErrorZ* 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_TrustedCommitmentTransactionNoneZ {
private:
LDKCResult_TrustedCommitmentTransactionNoneZ self;
const LDKCResult_COption_EventZDecodeErrorZ* operator &() const { return &self; }
const LDKCResult_COption_EventZDecodeErrorZ* operator ->() const { return &self; }
};
-class CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ {
+class CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ {
private:
- LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ self;
+ LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ 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; }
+ 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_PaymentFailureReasonDecodeErrorZ {
private:
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:
~CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ() { CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ_free(self); }
CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ& operator=(CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ&& o) { CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ)); return *this; }
LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ* operator &() { return &self; }
- LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ* operator ->() { return &self; }
- const LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ* operator &() const { return &self; }
- const LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ* operator ->() const { return &self; }
-};
-class CResult_PaymentRelayDecodeErrorZ {
-private:
- LDKCResult_PaymentRelayDecodeErrorZ self;
-public:
- CResult_PaymentRelayDecodeErrorZ(const CResult_PaymentRelayDecodeErrorZ&) = delete;
- CResult_PaymentRelayDecodeErrorZ(CResult_PaymentRelayDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentRelayDecodeErrorZ)); }
- CResult_PaymentRelayDecodeErrorZ(LDKCResult_PaymentRelayDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentRelayDecodeErrorZ)); }
- operator LDKCResult_PaymentRelayDecodeErrorZ() && { LDKCResult_PaymentRelayDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentRelayDecodeErrorZ)); return res; }
- ~CResult_PaymentRelayDecodeErrorZ() { CResult_PaymentRelayDecodeErrorZ_free(self); }
- CResult_PaymentRelayDecodeErrorZ& operator=(CResult_PaymentRelayDecodeErrorZ&& o) { CResult_PaymentRelayDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentRelayDecodeErrorZ)); return *this; }
- LDKCResult_PaymentRelayDecodeErrorZ* operator &() { return &self; }
- LDKCResult_PaymentRelayDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_PaymentRelayDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_PaymentRelayDecodeErrorZ* operator ->() const { return &self; }
+ LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ* operator ->() { return &self; }
+ const LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ* operator &() const { return &self; }
+ const LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ* operator ->() const { return &self; }
};
-class CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ {
+class CResult_NoneTxSyncErrorZ {
private:
- LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ self;
+ LDKCResult_NoneTxSyncErrorZ 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; }
+ CResult_NoneTxSyncErrorZ(const CResult_NoneTxSyncErrorZ&) = delete;
+ CResult_NoneTxSyncErrorZ(CResult_NoneTxSyncErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneTxSyncErrorZ)); }
+ CResult_NoneTxSyncErrorZ(LDKCResult_NoneTxSyncErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneTxSyncErrorZ)); }
+ operator LDKCResult_NoneTxSyncErrorZ() && { LDKCResult_NoneTxSyncErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneTxSyncErrorZ)); return res; }
+ ~CResult_NoneTxSyncErrorZ() { CResult_NoneTxSyncErrorZ_free(self); }
+ CResult_NoneTxSyncErrorZ& operator=(CResult_NoneTxSyncErrorZ&& o) { CResult_NoneTxSyncErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneTxSyncErrorZ)); return *this; }
+ LDKCResult_NoneTxSyncErrorZ* operator &() { return &self; }
+ LDKCResult_NoneTxSyncErrorZ* operator ->() { return &self; }
+ const LDKCResult_NoneTxSyncErrorZ* operator &() const { return &self; }
+ const LDKCResult_NoneTxSyncErrorZ* operator ->() const { return &self; }
+};
+class CResult_DescriptionCreationErrorZ {
+private:
+ LDKCResult_DescriptionCreationErrorZ self;
+public:
+ CResult_DescriptionCreationErrorZ(const CResult_DescriptionCreationErrorZ&) = delete;
+ CResult_DescriptionCreationErrorZ(CResult_DescriptionCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_DescriptionCreationErrorZ)); }
+ CResult_DescriptionCreationErrorZ(LDKCResult_DescriptionCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_DescriptionCreationErrorZ)); }
+ operator LDKCResult_DescriptionCreationErrorZ() && { LDKCResult_DescriptionCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_DescriptionCreationErrorZ)); return res; }
+ ~CResult_DescriptionCreationErrorZ() { CResult_DescriptionCreationErrorZ_free(self); }
+ CResult_DescriptionCreationErrorZ& operator=(CResult_DescriptionCreationErrorZ&& o) { CResult_DescriptionCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_DescriptionCreationErrorZ)); return *this; }
+ LDKCResult_DescriptionCreationErrorZ* operator &() { return &self; }
+ LDKCResult_DescriptionCreationErrorZ* operator ->() { return &self; }
+ const LDKCResult_DescriptionCreationErrorZ* operator &() const { return &self; }
+ const LDKCResult_DescriptionCreationErrorZ* operator ->() const { return &self; }
};
class CResult_QueryShortChannelIdsDecodeErrorZ {
private:
const LDKCResult_UpdateAddHTLCDecodeErrorZ* operator &() const { return &self; }
const LDKCResult_UpdateAddHTLCDecodeErrorZ* operator ->() const { return &self; }
};
+class CResult_PaymentRelayDecodeErrorZ {
+private:
+ LDKCResult_PaymentRelayDecodeErrorZ self;
+public:
+ CResult_PaymentRelayDecodeErrorZ(const CResult_PaymentRelayDecodeErrorZ&) = delete;
+ CResult_PaymentRelayDecodeErrorZ(CResult_PaymentRelayDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentRelayDecodeErrorZ)); }
+ CResult_PaymentRelayDecodeErrorZ(LDKCResult_PaymentRelayDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentRelayDecodeErrorZ)); }
+ operator LDKCResult_PaymentRelayDecodeErrorZ() && { LDKCResult_PaymentRelayDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentRelayDecodeErrorZ)); return res; }
+ ~CResult_PaymentRelayDecodeErrorZ() { CResult_PaymentRelayDecodeErrorZ_free(self); }
+ CResult_PaymentRelayDecodeErrorZ& operator=(CResult_PaymentRelayDecodeErrorZ&& o) { CResult_PaymentRelayDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentRelayDecodeErrorZ)); return *this; }
+ LDKCResult_PaymentRelayDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_PaymentRelayDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_PaymentRelayDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_PaymentRelayDecodeErrorZ* 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;
const LDKCResult_UpdateFailHTLCDecodeErrorZ* operator &() const { return &self; }
const LDKCResult_UpdateFailHTLCDecodeErrorZ* operator ->() const { return &self; }
};
+class CResult_CVec_BlindedPathZNoneZ {
+private:
+ LDKCResult_CVec_BlindedPathZNoneZ self;
+public:
+ CResult_CVec_BlindedPathZNoneZ(const CResult_CVec_BlindedPathZNoneZ&) = delete;
+ CResult_CVec_BlindedPathZNoneZ(CResult_CVec_BlindedPathZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_BlindedPathZNoneZ)); }
+ CResult_CVec_BlindedPathZNoneZ(LDKCResult_CVec_BlindedPathZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_BlindedPathZNoneZ)); }
+ operator LDKCResult_CVec_BlindedPathZNoneZ() && { LDKCResult_CVec_BlindedPathZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_BlindedPathZNoneZ)); return res; }
+ ~CResult_CVec_BlindedPathZNoneZ() { CResult_CVec_BlindedPathZNoneZ_free(self); }
+ CResult_CVec_BlindedPathZNoneZ& operator=(CResult_CVec_BlindedPathZNoneZ&& o) { CResult_CVec_BlindedPathZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_BlindedPathZNoneZ)); return *this; }
+ LDKCResult_CVec_BlindedPathZNoneZ* operator &() { return &self; }
+ LDKCResult_CVec_BlindedPathZNoneZ* operator ->() { return &self; }
+ const LDKCResult_CVec_BlindedPathZNoneZ* operator &() const { return &self; }
+ const LDKCResult_CVec_BlindedPathZNoneZ* 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;
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;
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:
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 COption_BigEndianScalarZ {
private:
LDKCOption_BigEndianScalarZ self;
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;
const LDKCResult_InvoiceErrorDecodeErrorZ* operator &() const { return &self; }
const LDKCResult_InvoiceErrorDecodeErrorZ* 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 C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ {
private:
LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ self;
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;
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;
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:
const LDKCOption_PathFailureZ* operator &() const { return &self; }
const LDKCOption_PathFailureZ* operator ->() const { return &self; }
};
+class CResult_StrSecp256k1ErrorZ {
+private:
+ LDKCResult_StrSecp256k1ErrorZ 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; }
+};
class CVec_ECDSASignatureZ {
private:
LDKCVec_ECDSASignatureZ self;
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;
const LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
const LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* 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;
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;
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;
const LDKCResult_TxAddInputDecodeErrorZ* operator &() const { return &self; }
const LDKCResult_TxAddInputDecodeErrorZ* operator ->() const { return &self; }
};
-class CVec_OutPointZ {
+class CResult_PeeledOnionNoneZ {
private:
- LDKCVec_OutPointZ self;
+ LDKCResult_PeeledOnionNoneZ 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_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_TxInitRbfDecodeErrorZ {
private:
const LDKCVec_StrZ* operator &() const { return &self; }
const LDKCVec_StrZ* 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;
const LDKCResult_PositiveTimestampCreationErrorZ* operator &() const { return &self; }
const LDKCResult_PositiveTimestampCreationErrorZ* 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;
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;
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 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 CResult_BlindedHopFeaturesDecodeErrorZ {
private:
LDKCResult_BlindedHopFeaturesDecodeErrorZ self;
const LDKCOption_boolZ* operator &() const { return &self; }
const LDKCOption_boolZ* operator ->() const { return &self; }
};
-class CVec_CVec_u8ZZ {
+class COption_StrZ {
private:
- LDKCVec_CVec_u8ZZ self;
+ LDKCOption_StrZ 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; }
+ COption_StrZ(const COption_StrZ&) = delete;
+ COption_StrZ(COption_StrZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_StrZ)); }
+ COption_StrZ(LDKCOption_StrZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_StrZ)); }
+ operator LDKCOption_StrZ() && { LDKCOption_StrZ res = self; memset(&self, 0, sizeof(LDKCOption_StrZ)); return res; }
+ ~COption_StrZ() { COption_StrZ_free(self); }
+ COption_StrZ& operator=(COption_StrZ&& o) { COption_StrZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_StrZ)); return *this; }
+ LDKCOption_StrZ* operator &() { return &self; }
+ LDKCOption_StrZ* operator ->() { return &self; }
+ const LDKCOption_StrZ* operator &() const { return &self; }
+ const LDKCOption_StrZ* operator ->() const { return &self; }
};
class CResult_ProbabilisticScorerDecodeErrorZ {
private:
const LDKCResult_ProbabilisticScorerDecodeErrorZ* operator &() const { return &self; }
const LDKCResult_ProbabilisticScorerDecodeErrorZ* operator ->() const { return &self; }
};
-class CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ {
+class CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ {
private:
- LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ self;
+ LDKCResult_COption_InboundHTLCStateDetailsZDecodeErrorZ 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;
-public:
- COption_StrZ(const COption_StrZ&) = delete;
- COption_StrZ(COption_StrZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_StrZ)); }
- COption_StrZ(LDKCOption_StrZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_StrZ)); }
- operator LDKCOption_StrZ() && { LDKCOption_StrZ res = self; memset(&self, 0, sizeof(LDKCOption_StrZ)); return res; }
- ~COption_StrZ() { COption_StrZ_free(self); }
- COption_StrZ& operator=(COption_StrZ&& o) { COption_StrZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_StrZ)); return *this; }
- LDKCOption_StrZ* operator &() { return &self; }
- LDKCOption_StrZ* operator ->() { return &self; }
- const LDKCOption_StrZ* operator &() const { return &self; }
- const LDKCOption_StrZ* 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_ShutdownScriptDecodeErrorZ {
private:
const LDKCResult_ShutdownScriptDecodeErrorZ* operator &() const { return &self; }
const LDKCResult_ShutdownScriptDecodeErrorZ* operator ->() const { return &self; }
};
+class CResult_ElectrumSyncClientTxSyncErrorZ {
+private:
+ LDKCResult_ElectrumSyncClientTxSyncErrorZ self;
+public:
+ CResult_ElectrumSyncClientTxSyncErrorZ(const CResult_ElectrumSyncClientTxSyncErrorZ&) = delete;
+ CResult_ElectrumSyncClientTxSyncErrorZ(CResult_ElectrumSyncClientTxSyncErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ElectrumSyncClientTxSyncErrorZ)); }
+ CResult_ElectrumSyncClientTxSyncErrorZ(LDKCResult_ElectrumSyncClientTxSyncErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ElectrumSyncClientTxSyncErrorZ)); }
+ operator LDKCResult_ElectrumSyncClientTxSyncErrorZ() && { LDKCResult_ElectrumSyncClientTxSyncErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ElectrumSyncClientTxSyncErrorZ)); return res; }
+ ~CResult_ElectrumSyncClientTxSyncErrorZ() { CResult_ElectrumSyncClientTxSyncErrorZ_free(self); }
+ CResult_ElectrumSyncClientTxSyncErrorZ& operator=(CResult_ElectrumSyncClientTxSyncErrorZ&& o) { CResult_ElectrumSyncClientTxSyncErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ElectrumSyncClientTxSyncErrorZ)); return *this; }
+ LDKCResult_ElectrumSyncClientTxSyncErrorZ* operator &() { return &self; }
+ LDKCResult_ElectrumSyncClientTxSyncErrorZ* operator ->() { return &self; }
+ const LDKCResult_ElectrumSyncClientTxSyncErrorZ* operator &() const { return &self; }
+ const LDKCResult_ElectrumSyncClientTxSyncErrorZ* operator ->() const { return &self; }
+};
class C2Tuple_usizeTransactionZ {
private:
LDKC2Tuple_usizeTransactionZ self;
const LDKCVec_ChannelMonitorZ* operator &() const { return &self; }
const LDKCVec_ChannelMonitorZ* operator ->() const { return &self; }
};
+class CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ {
+private:
+ LDKCVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ self;
+public:
+ CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ(const CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ&) = delete;
+ CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ(CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ)); }
+ CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ(LDKCVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ)); }
+ operator LDKCVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ() && { LDKCVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ)); return res; }
+ ~CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ() { CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ_free(self); }
+ CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ& operator=(CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ&& o) { CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ)); return *this; }
+ LDKCVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ* operator &() { return &self; }
+ LDKCVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ* operator ->() { return &self; }
+ const LDKCVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ* operator &() const { return &self; }
+ const LDKCVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ* operator ->() const { return &self; }
+};
class CResult_AcceptChannelV2DecodeErrorZ {
private:
LDKCResult_AcceptChannelV2DecodeErrorZ self;
const LDKCResult_AcceptChannelV2DecodeErrorZ* operator &() const { return &self; }
const LDKCResult_AcceptChannelV2DecodeErrorZ* operator ->() const { return &self; }
};
-class CResult_TxCreationKeysDecodeErrorZ {
-private:
- LDKCResult_TxCreationKeysDecodeErrorZ self;
-public:
- CResult_TxCreationKeysDecodeErrorZ(const CResult_TxCreationKeysDecodeErrorZ&) = delete;
- CResult_TxCreationKeysDecodeErrorZ(CResult_TxCreationKeysDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxCreationKeysDecodeErrorZ)); }
- CResult_TxCreationKeysDecodeErrorZ(LDKCResult_TxCreationKeysDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxCreationKeysDecodeErrorZ)); }
- operator LDKCResult_TxCreationKeysDecodeErrorZ() && { LDKCResult_TxCreationKeysDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxCreationKeysDecodeErrorZ)); return res; }
- ~CResult_TxCreationKeysDecodeErrorZ() { CResult_TxCreationKeysDecodeErrorZ_free(self); }
- CResult_TxCreationKeysDecodeErrorZ& operator=(CResult_TxCreationKeysDecodeErrorZ&& o) { CResult_TxCreationKeysDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxCreationKeysDecodeErrorZ)); return *this; }
- LDKCResult_TxCreationKeysDecodeErrorZ* operator &() { return &self; }
- LDKCResult_TxCreationKeysDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_TxCreationKeysDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_TxCreationKeysDecodeErrorZ* operator ->() const { return &self; }
-};
class CResult_RouteHopDecodeErrorZ {
private:
LDKCResult_RouteHopDecodeErrorZ self;
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;
const LDKCResult_CoinSelectionNoneZ* operator &() const { return &self; }
const LDKCResult_CoinSelectionNoneZ* operator ->() const { return &self; }
};
-class C2Tuple_ThirtyTwoBytesPublicKeyZ {
+class CResult_TxCreationKeysDecodeErrorZ {
private:
- LDKC2Tuple_ThirtyTwoBytesPublicKeyZ self;
+ LDKCResult_TxCreationKeysDecodeErrorZ 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; }
+ CResult_TxCreationKeysDecodeErrorZ(const CResult_TxCreationKeysDecodeErrorZ&) = delete;
+ CResult_TxCreationKeysDecodeErrorZ(CResult_TxCreationKeysDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxCreationKeysDecodeErrorZ)); }
+ CResult_TxCreationKeysDecodeErrorZ(LDKCResult_TxCreationKeysDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxCreationKeysDecodeErrorZ)); }
+ operator LDKCResult_TxCreationKeysDecodeErrorZ() && { LDKCResult_TxCreationKeysDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxCreationKeysDecodeErrorZ)); return res; }
+ ~CResult_TxCreationKeysDecodeErrorZ() { CResult_TxCreationKeysDecodeErrorZ_free(self); }
+ CResult_TxCreationKeysDecodeErrorZ& operator=(CResult_TxCreationKeysDecodeErrorZ&& o) { CResult_TxCreationKeysDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxCreationKeysDecodeErrorZ)); return *this; }
+ LDKCResult_TxCreationKeysDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_TxCreationKeysDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_TxCreationKeysDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_TxCreationKeysDecodeErrorZ* operator ->() const { return &self; }
};
class CResult_SiPrefixBolt11ParseErrorZ {
private:
const LDKCResult_SiPrefixBolt11ParseErrorZ* operator &() const { return &self; }
const LDKCResult_SiPrefixBolt11ParseErrorZ* operator ->() const { return &self; }
};
-class CResult_BlindedPathDecodeErrorZ {
-private:
- LDKCResult_BlindedPathDecodeErrorZ 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; }
-};
-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:
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;
const LDKC2Tuple_Z* operator &() const { return &self; }
const LDKC2Tuple_Z* operator ->() const { return &self; }
};
+class CResult_BlindedPathDecodeErrorZ {
+private:
+ LDKCResult_BlindedPathDecodeErrorZ 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; }
+};
+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 C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ {
private:
LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ self;
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;
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;
const LDKCResult_ChannelCounterpartyDecodeErrorZ* operator &() const { return &self; }
const LDKCResult_ChannelCounterpartyDecodeErrorZ* operator ->() const { return &self; }
};
+class CResult_HolderCommitmentTransactionDecodeErrorZ {
+private:
+ LDKCResult_HolderCommitmentTransactionDecodeErrorZ self;
+public:
+ CResult_HolderCommitmentTransactionDecodeErrorZ(const CResult_HolderCommitmentTransactionDecodeErrorZ&) = delete;
+ CResult_HolderCommitmentTransactionDecodeErrorZ(CResult_HolderCommitmentTransactionDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HolderCommitmentTransactionDecodeErrorZ)); }
+ CResult_HolderCommitmentTransactionDecodeErrorZ(LDKCResult_HolderCommitmentTransactionDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ)); }
+ operator LDKCResult_HolderCommitmentTransactionDecodeErrorZ() && { LDKCResult_HolderCommitmentTransactionDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ)); return res; }
+ ~CResult_HolderCommitmentTransactionDecodeErrorZ() { CResult_HolderCommitmentTransactionDecodeErrorZ_free(self); }
+ CResult_HolderCommitmentTransactionDecodeErrorZ& operator=(CResult_HolderCommitmentTransactionDecodeErrorZ&& o) { CResult_HolderCommitmentTransactionDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HolderCommitmentTransactionDecodeErrorZ)); return *this; }
+ LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator ->() const { return &self; }
+};
+class CVec_ForwardNodeZ {
+private:
+ LDKCVec_ForwardNodeZ self;
+public:
+ CVec_ForwardNodeZ(const CVec_ForwardNodeZ&) = delete;
+ CVec_ForwardNodeZ(CVec_ForwardNodeZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ForwardNodeZ)); }
+ CVec_ForwardNodeZ(LDKCVec_ForwardNodeZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ForwardNodeZ)); }
+ operator LDKCVec_ForwardNodeZ() && { LDKCVec_ForwardNodeZ res = self; memset(&self, 0, sizeof(LDKCVec_ForwardNodeZ)); return res; }
+ ~CVec_ForwardNodeZ() { CVec_ForwardNodeZ_free(self); }
+ CVec_ForwardNodeZ& operator=(CVec_ForwardNodeZ&& o) { CVec_ForwardNodeZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ForwardNodeZ)); return *this; }
+ LDKCVec_ForwardNodeZ* operator &() { return &self; }
+ LDKCVec_ForwardNodeZ* operator ->() { return &self; }
+ const LDKCVec_ForwardNodeZ* operator &() const { return &self; }
+ const LDKCVec_ForwardNodeZ* 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 CResult_InitDecodeErrorZ {
private:
LDKCResult_InitDecodeErrorZ self;
const LDKCResult_InitDecodeErrorZ* operator &() const { return &self; }
const LDKCResult_InitDecodeErrorZ* 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:
LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ self;
const LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ* operator &() const { return &self; }
const LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ* operator ->() const { return &self; }
};
-class CResult_ClaimedHTLCDecodeErrorZ {
+class CResult_SpliceDecodeErrorZ {
private:
- LDKCResult_ClaimedHTLCDecodeErrorZ self;
+ LDKCResult_SpliceDecodeErrorZ 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_SpliceDecodeErrorZ(const CResult_SpliceDecodeErrorZ&) = delete;
+ CResult_SpliceDecodeErrorZ(CResult_SpliceDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SpliceDecodeErrorZ)); }
+ CResult_SpliceDecodeErrorZ(LDKCResult_SpliceDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SpliceDecodeErrorZ)); }
+ operator LDKCResult_SpliceDecodeErrorZ() && { LDKCResult_SpliceDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SpliceDecodeErrorZ)); return res; }
+ ~CResult_SpliceDecodeErrorZ() { CResult_SpliceDecodeErrorZ_free(self); }
+ CResult_SpliceDecodeErrorZ& operator=(CResult_SpliceDecodeErrorZ&& o) { CResult_SpliceDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SpliceDecodeErrorZ)); return *this; }
+ LDKCResult_SpliceDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_SpliceDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_SpliceDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_SpliceDecodeErrorZ* operator ->() const { return &self; }
};
class CResult_PaymentPurposeDecodeErrorZ {
private:
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:
const LDKCVec_ChannelDetailsZ* operator &() const { return &self; }
const LDKCVec_ChannelDetailsZ* 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_Bolt11InvoiceFeaturesDecodeErrorZ {
private:
LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ self;
const LDKCVec_MessageSendEventZ* operator &() const { return &self; }
const LDKCVec_MessageSendEventZ* operator ->() const { return &self; }
};
+class CVec_MonitorUpdateIdZ {
+private:
+ LDKCVec_MonitorUpdateIdZ self;
+public:
+ CVec_MonitorUpdateIdZ(const CVec_MonitorUpdateIdZ&) = delete;
+ CVec_MonitorUpdateIdZ(CVec_MonitorUpdateIdZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_MonitorUpdateIdZ)); }
+ CVec_MonitorUpdateIdZ(LDKCVec_MonitorUpdateIdZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_MonitorUpdateIdZ)); }
+ operator LDKCVec_MonitorUpdateIdZ() && { LDKCVec_MonitorUpdateIdZ res = self; memset(&self, 0, sizeof(LDKCVec_MonitorUpdateIdZ)); return res; }
+ ~CVec_MonitorUpdateIdZ() { CVec_MonitorUpdateIdZ_free(self); }
+ CVec_MonitorUpdateIdZ& operator=(CVec_MonitorUpdateIdZ&& o) { CVec_MonitorUpdateIdZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_MonitorUpdateIdZ)); return *this; }
+ LDKCVec_MonitorUpdateIdZ* operator &() { return &self; }
+ LDKCVec_MonitorUpdateIdZ* operator ->() { return &self; }
+ const LDKCVec_MonitorUpdateIdZ* operator &() const { return &self; }
+ const LDKCVec_MonitorUpdateIdZ* operator ->() const { return &self; }
+};
class CResult_RouteHintHopDecodeErrorZ {
private:
LDKCResult_RouteHintHopDecodeErrorZ self;
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;
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:
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 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_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 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 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 COption_EventZ {
private:
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;
const LDKCResult_ECDSASignatureNoneZ* operator &() const { return &self; }
const LDKCResult_ECDSASignatureNoneZ* operator ->() const { return &self; }
};
+class CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ {
+private:
+ LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ self;
+public:
+ CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ(const CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ&) = delete;
+ CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ(CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ)); }
+ CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ(LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ)); }
+ operator LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ() && { LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ)); return res; }
+ ~CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ() { CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_free(self); }
+ CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ& operator=(CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ&& o) { CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ)); return *this; }
+ LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ* operator &() { return &self; }
+ LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ* operator ->() { return &self; }
+ const LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ* operator &() const { return &self; }
+ const LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ* 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 CVec_WitnessZ {
private:
LDKCVec_WitnessZ self;
const LDKCResult_PaymentConstraintsDecodeErrorZ* operator &() const { return &self; }
const LDKCResult_PaymentConstraintsDecodeErrorZ* 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:
LDKC2Tuple_u32CVec_u8ZZ self;
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:
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:
const LDKCVec_C2Tuple_u64CVec_u8ZZZ* operator &() const { return &self; }
const LDKCVec_C2Tuple_u64CVec_u8ZZZ* operator ->() const { return &self; }
};
-class CResult_u32GraphSyncErrorZ {
-private:
- LDKCResult_u32GraphSyncErrorZ self;
-public:
- CResult_u32GraphSyncErrorZ(const CResult_u32GraphSyncErrorZ&) = delete;
- CResult_u32GraphSyncErrorZ(CResult_u32GraphSyncErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_u32GraphSyncErrorZ)); }
- CResult_u32GraphSyncErrorZ(LDKCResult_u32GraphSyncErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_u32GraphSyncErrorZ)); }
- operator LDKCResult_u32GraphSyncErrorZ() && { LDKCResult_u32GraphSyncErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_u32GraphSyncErrorZ)); return res; }
- ~CResult_u32GraphSyncErrorZ() { CResult_u32GraphSyncErrorZ_free(self); }
- CResult_u32GraphSyncErrorZ& operator=(CResult_u32GraphSyncErrorZ&& o) { CResult_u32GraphSyncErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_u32GraphSyncErrorZ)); return *this; }
- LDKCResult_u32GraphSyncErrorZ* operator &() { return &self; }
- LDKCResult_u32GraphSyncErrorZ* operator ->() { return &self; }
- const LDKCResult_u32GraphSyncErrorZ* operator &() const { return &self; }
- const LDKCResult_u32GraphSyncErrorZ* operator ->() const { return &self; }
-};
class CVec_PhantomRouteHintsZ {
private:
LDKCVec_PhantomRouteHintsZ self;
const LDKCVec_PhantomRouteHintsZ* operator &() const { return &self; }
const LDKCVec_PhantomRouteHintsZ* operator ->() const { return &self; }
};
+class CResult_OffersMessageDecodeErrorZ {
+private:
+ LDKCResult_OffersMessageDecodeErrorZ 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; }
+};
class CResult_NoneAPIErrorZ {
private:
LDKCResult_NoneAPIErrorZ self;
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:
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;
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;
const LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ* operator &() const { return &self; }
const LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ* operator ->() const { return &self; }
};
-class CResult_OffersMessageDecodeErrorZ {
+class CResult_PendingHTLCRoutingDecodeErrorZ {
private:
- LDKCResult_OffersMessageDecodeErrorZ self;
+ LDKCResult_PendingHTLCRoutingDecodeErrorZ 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_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 C2Tuple_u64u64Z {
private:
const LDKC2Tuple_u64u64Z* operator &() const { return &self; }
const LDKC2Tuple_u64u64Z* 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 CResult_CounterpartyChannelTransactionParametersDecodeErrorZ {
private:
LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ self;
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_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_UtxoZ {
private:
LDKCVec_UtxoZ self;
const LDKCOption_usizeZ* operator &() const { return &self; }
const LDKCOption_usizeZ* operator ->() const { return &self; }
};
-class CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ {
-private:
- LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ self;
-public:
- CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ(const CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ&) = delete;
- CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ(CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ)); }
- CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ(LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ)); }
- operator LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ() && { LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ res = self; memset(&self, 0, sizeof(LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ)); return res; }
- ~CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ() { CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(self); }
- CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ& operator=(CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ&& o) { CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ)); return *this; }
- LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ* operator &() { return &self; }
- LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ* operator ->() { return &self; }
- const LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ* operator &() const { return &self; }
- const LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ* operator ->() const { return &self; }
-};
class CResult_NoneNoneZ {
private:
LDKCResult_NoneNoneZ self;
const LDKCResult_TransactionU16LenLimitedDecodeErrorZ* operator &() const { return &self; }
const LDKCResult_TransactionU16LenLimitedDecodeErrorZ* 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 CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ {
private:
LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ self;
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;
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;
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:
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;
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:
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 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 LDKPublicKey ChannelSigner::get_per_commitment_point(uint64_t idx) {
LDKPublicKey ret = (self.get_per_commitment_point)(self.this_arg, idx);
return ret;
LDKThirtyTwoBytes ret = (self.release_commitment_secret)(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);
+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 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 LDKThirtyTwoBytes ChannelSigner::channel_keys_id() {
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);
- return ret;
-}
-inline LDK::CResult_NoneNoneZ EcdsaChannelSigner::validate_counterparty_revocation(uint64_t idx, const uint8_t (*secret)[32]) {
- LDK::CResult_NoneNoneZ ret = (self.validate_counterparty_revocation)(self.this_arg, idx, secret);
- return ret;
-}
-inline LDK::CResult_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 LDKThirtyTwoBytes EntropySource::get_secure_random_bytes() {
LDKThirtyTwoBytes ret = (self.get_secure_random_bytes)(self.this_arg);
return ret;
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;
LDK::CResult_WriteableEcdsaChannelSignerDecodeErrorZ 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;
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_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ Router::create_blinded_payment_paths(struct LDKPublicKey recipient, struct LDKCVec_ChannelDetailsZ first_hops, struct LDKReceiveTlvs tlvs, uint64_t amount_msats) {
+ LDK::CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ ret = (self.create_blinded_payment_paths)(self.this_arg, recipient, first_hops, tlvs, amount_msats);
+ return ret;
+}
+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) {
- (self.payment_path_failed)(self.this_arg, path, short_channel_id);
+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, uint64_t duration_since_epoch) {
+ (self.payment_path_successful)(self.this_arg, path, 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::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_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_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::probe_successful(const struct LDKPath *NONNULL_PTR path) {
- (self.probe_successful)(self.this_arg, path);
+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);
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) {
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) {
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() {
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) {
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);
}
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);
}
LDK::InitFeatures ret = (self.provided_init_features)(self.this_arg, their_node_id);
return ret;
}
+inline LDK::CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ OnionMessageHandler::get_and_clear_connections_needed() {
+ LDK::CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ ret = (self.get_and_clear_connections_needed)(self.this_arg);
+ return ret;
+}
inline void OnionMessageHandler::handle_onion_message(struct LDKPublicKey peer_node_id, const struct LDKOnionMessage *NONNULL_PTR msg) {
(self.handle_onion_message)(self.this_arg, peer_node_id, msg);
}
inline 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;
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() {
uint64_t ret = (self.tlv_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;
LDK::CResult_OnionMessagePathNoneZ ret = (self.find_path)(self.this_arg, sender, peers, destination);
return ret;
}
+inline LDK::CResult_CVec_BlindedPathZNoneZ MessageRouter::create_blinded_paths(struct LDKPublicKey recipient, struct LDKCVec_PublicKeyZ peers) {
+ LDK::CResult_CVec_BlindedPathZNoneZ ret = (self.create_blinded_paths)(self.this_arg, recipient, peers);
+ 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);
return ret;
LDK::CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ ret = (self.release_pending_custom_messages)(self.this_arg);
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 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_funding_outpoint, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id) {
+ LDK::ChannelMonitorUpdateStatus ret = (self.persist_new_channel)(self.this_arg, channel_funding_outpoint, data, update_id);
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 update, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id) {
+ LDK::ChannelMonitorUpdateStatus ret = (self.update_persisted_channel)(self.this_arg, channel_funding_outpoint, update, data, update_id);
return ret;
}
+inline void Persist::archive_persisted_channel(struct LDKOutPoint channel_funding_outpoint) {
+ (self.archive_persisted_channel)(self.this_arg, channel_funding_outpoint);
+}
}